From 40e65d759b4f13db30aec90a040a5fe769ac4a98 Mon Sep 17 00:00:00 2001 From: Shylock Hg <33566796+Shylock-Hg@users.noreply.github.com> Date: Tue, 12 Oct 2021 17:11:52 +0800 Subject: [PATCH 01/14] Decouple the client and server source code. --- .linters/cpp/hooks/pre-commit.sh | 2 +- CMakeLists.txt | 81 +- cmake/CPackage.cmake | 170 + cmake/ClangTidy.cmake | 13 + cmake/FetchModule.cmake | 63 +- cmake/FindBreakpad.cmake | 33 + cmake/FindBzip2.cmake | 34 + cmake/FindDoubleConversion.cmake | 30 + cmake/FindFatal.cmake | 27 + cmake/FindFbthrift.cmake | 33 + cmake/FindFizz.cmake | 30 + cmake/FindFolly.cmake | 30 + cmake/FindGPERF.cmake | 61 + cmake/FindGflags.cmake | 30 + cmake/FindGlog.cmake | 30 + cmake/FindGoogletest.cmake | 30 + cmake/FindJemalloc.cmake | 29 + cmake/FindKrb5.cmake | 169 + cmake/FindLibevent.cmake | 30 + cmake/FindLibunwind.cmake | 24 + cmake/FindMstch.cmake | 32 + cmake/FindNCURSES.cmake | 49 + cmake/FindPCHSupport.cmake | 95 + cmake/FindProxygen.cmake | 31 + cmake/FindReadline.cmake | 47 + cmake/FindRocksdb.cmake | 30 + cmake/FindSnappy.cmake | 30 + cmake/FindSodium.cmake | 30 + cmake/FindWangle.cmake | 30 + cmake/FindZstd.cmake | 32 + cmake/ThriftGenerate.cmake | 138 + cmake/nebula/ABIConfig.cmake | 8 + cmake/nebula/CcacheConfig.cmake | 16 + cmake/nebula/GeneralCMakeConfig.cmake | 25 + cmake/nebula/GeneralCMakeOptions.cmake | 28 + cmake/nebula/GeneralCompilerConfig.cmake | 92 + cmake/nebula/GitHooksConfig.cmake | 19 + cmake/nebula/GitInfoConfig.cmake | 12 + cmake/nebula/InstallThirdParty.cmake | 28 + cmake/nebula/LinkerConfig.cmake | 57 + cmake/nebula/MakeBisonRelocatable.cmake | 17 + cmake/nebula/NebulaCMakeMacros.cmake | 168 + cmake/nebula/NebulaCustomTargets.cmake | 30 + cmake/nebula/PlatformCheck.cmake | 3 + cmake/nebula/SanitizerConfig.cmake | 62 + cmake/nebula/ThirdPartyConfig.cmake | 160 + gen-interface.sh | 38 + include/common/datatypes/CommonCpp2Ops.h | 49 + include/common/datatypes/DataSet.h | 185 + include/common/datatypes/DataSetOps-inl.h | 183 + include/common/datatypes/Date.h | 239 + include/common/datatypes/DateOps-inl.h | 724 + include/common/datatypes/Edge.h | 86 + include/common/datatypes/EdgeOps-inl.h | 291 + include/common/datatypes/Geography.h | 82 + include/common/datatypes/GeographyOps-inl.h | 130 + include/common/datatypes/HostAddr.h | 66 + include/common/datatypes/HostAddrOps-inl.h | 163 + include/common/datatypes/KeyValue.h | 45 + include/common/datatypes/KeyValueOps-inl.h | 158 + include/common/datatypes/List.h | 104 + include/common/datatypes/ListOps-inl.h | 137 + include/common/datatypes/Map.h | 80 + include/common/datatypes/MapOps-inl.h | 139 + include/common/datatypes/Path.h | 204 + include/common/datatypes/PathOps-inl.h | 422 + include/common/datatypes/Set.h | 68 + include/common/datatypes/SetOps-inl.h | 136 + include/common/datatypes/Value.h | 515 + include/common/datatypes/ValueOps-inl.h | 730 + include/common/datatypes/Vertex.h | 120 + include/common/datatypes/VertexOps-inl.h | 315 + include/common/graph/AuthResponseOps-inl.h | 294 + .../common/graph/ExecutionResponseOps-inl.h | 353 + include/common/graph/GraphCpp2Ops.h | 31 + include/common/graph/PairOps-inl.h | 166 + include/common/graph/PlanDescriptionOps-inl.h | 259 + .../common/graph/PlanNodeBranchInfoOps-inl.h | 180 + .../common/graph/PlanNodeDescriptionOps-inl.h | 364 + include/common/graph/ProfilingStatsOps-inl.h | 266 + include/common/graph/Response.h | 420 + include/common/thrift/ThriftCpp2OpsHelper.h | 27 + include/common/thrift/ThriftTypes.h | 49 + include/common/time/TimeConversion.h | 120 + include/common/utils/utils.h | 16 + include/nebula/client/Connection.h | 4 +- include/nebula/client/ConnectionPool.h | 4 +- include/nebula/client/Session.h | 2 +- src/CMakeLists.txt | 22 +- src/client/Connection.cpp | 2 +- src/client/Session.cpp | 4 +- src/datatypes/Date.cpp | 144 + src/datatypes/Edge.cpp | 112 + src/datatypes/Geography.cpp | 23 + src/datatypes/HostAddr.cpp | 40 + src/datatypes/List.cpp | 25 + src/datatypes/Map.cpp | 28 + src/datatypes/Path.cpp | 101 + src/datatypes/Set.cpp | 25 + src/datatypes/Value.cpp | 2786 ++ src/datatypes/Vertex.cpp | 108 + src/graph/Response.cpp | 41 + src/interface/CMakeLists.txt | 54 + .../gen-cpp2/GeneralStorageService.cpp | 125 + .../gen-cpp2/GeneralStorageService.h | 123 + .../gen-cpp2/GeneralStorageService.tcc | 192 + .../GeneralStorageServiceAsyncClient.cpp | 563 + .../GeneralStorageServiceAsyncClient.h | 280 + .../GeneralStorageService_custom_protocol.h | 19 + ...eneralStorageService_processmap_binary.cpp | 12 + ...neralStorageService_processmap_compact.cpp | 12 + src/interface/gen-cpp2/GraphService.cpp | 179 + src/interface/gen-cpp2/GraphService.h | 157 + src/interface/gen-cpp2/GraphService.tcc | 289 + .../gen-cpp2/GraphServiceAsyncClient.cpp | 860 + .../gen-cpp2/GraphServiceAsyncClient.h | 430 + .../gen-cpp2/GraphService_custom_protocol.h | 18 + .../GraphService_processmap_binary.cpp | 12 + .../GraphService_processmap_compact.cpp | 12 + .../gen-cpp2/GraphStorageService.cpp | 450 + src/interface/gen-cpp2/GraphStorageService.h | 331 + .../gen-cpp2/GraphStorageService.tcc | 959 + .../GraphStorageServiceAsyncClient.cpp | 2929 ++ .../gen-cpp2/GraphStorageServiceAsyncClient.h | 1346 + .../GraphStorageService_custom_protocol.h | 19 + .../GraphStorageService_processmap_binary.cpp | 12 + ...GraphStorageService_processmap_compact.cpp | 12 + .../gen-cpp2/InternalStorageService.cpp | 100 + .../gen-cpp2/InternalStorageService.h | 107 + .../gen-cpp2/InternalStorageService.tcc | 133 + .../InternalStorageServiceAsyncClient.cpp | 381 + .../InternalStorageServiceAsyncClient.h | 198 + .../InternalStorageService_custom_protocol.h | 19 + ...ternalStorageService_processmap_binary.cpp | 12 + ...ernalStorageService_processmap_compact.cpp | 12 + src/interface/gen-cpp2/MetaService.cpp | 2300 ++ src/interface/gen-cpp2/MetaService.h | 1514 + src/interface/gen-cpp2/MetaService.tcc | 5325 +++ .../gen-cpp2/MetaServiceAsyncClient.cpp | 16397 ++++++++ .../gen-cpp2/MetaServiceAsyncClient.h | 7413 ++++ .../gen-cpp2/MetaService_custom_protocol.h | 18 + .../MetaService_processmap_binary.cpp | 12 + .../MetaService_processmap_compact.cpp | 12 + .../gen-cpp2/StorageAdminService.cpp | 450 + src/interface/gen-cpp2/StorageAdminService.h | 331 + .../gen-cpp2/StorageAdminService.tcc | 959 + .../StorageAdminServiceAsyncClient.cpp | 2929 ++ .../gen-cpp2/StorageAdminServiceAsyncClient.h | 1346 + .../StorageAdminService_custom_protocol.h | 19 + .../StorageAdminService_processmap_binary.cpp | 12 + ...StorageAdminService_processmap_compact.cpp | 12 + src/interface/gen-cpp2/common_constants.cpp | 17 + src/interface/gen-cpp2/common_constants.h | 25 + src/interface/gen-cpp2/common_data.cpp | 698 + src/interface/gen-cpp2/common_data.h | 204 + .../gen-cpp2/common_for_each_field.h | 247 + src/interface/gen-cpp2/common_metadata.cpp | 648 + src/interface/gen-cpp2/common_metadata.h | 146 + src/interface/gen-cpp2/common_types.cpp | 2809 ++ src/interface/gen-cpp2/common_types.h | 5849 +++ src/interface/gen-cpp2/common_types.tcc | 4326 ++ .../gen-cpp2/common_types_custom_protocol.h | 18 + .../common_visit_by_thrift_field_metadata.h | 408 + src/interface/gen-cpp2/common_visit_union.h | 74 + src/interface/gen-cpp2/common_visitation.h | 9 + src/interface/gen-cpp2/graph_constants.cpp | 6 + src/interface/gen-cpp2/graph_constants.h | 19 + src/interface/gen-cpp2/graph_data.cpp | 181 + src/interface/gen-cpp2/graph_data.h | 78 + src/interface/gen-cpp2/graph_for_each_field.h | 114 + src/interface/gen-cpp2/graph_metadata.cpp | 388 + src/interface/gen-cpp2/graph_metadata.h | 83 + src/interface/gen-cpp2/graph_types.cpp | 1049 + src/interface/gen-cpp2/graph_types.h | 2174 + src/interface/gen-cpp2/graph_types.tcc | 1882 + .../gen-cpp2/graph_types_custom_protocol.h | 19 + .../graph_visit_by_thrift_field_metadata.h | 184 + src/interface/gen-cpp2/graph_visit_union.h | 18 + src/interface/gen-cpp2/graph_visitation.h | 10 + src/interface/gen-cpp2/meta_constants.cpp | 6 + src/interface/gen-cpp2/meta_constants.h | 19 + src/interface/gen-cpp2/meta_data.cpp | 2782 ++ src/interface/gen-cpp2/meta_data.h | 1324 + src/interface/gen-cpp2/meta_for_each_field.h | 1632 + src/interface/gen-cpp2/meta_metadata.cpp | 5934 +++ src/interface/gen-cpp2/meta_metadata.h | 1053 + src/interface/gen-cpp2/meta_types.cpp | 19319 +++++++++ src/interface/gen-cpp2/meta_types.h | 33986 ++++++++++++++++ src/interface/gen-cpp2/meta_types.tcc | 28488 +++++++++++++ .../gen-cpp2/meta_types_custom_protocol.h | 19 + .../meta_visit_by_thrift_field_metadata.h | 2743 ++ src/interface/gen-cpp2/meta_visit_union.h | 38 + src/interface/gen-cpp2/meta_visitation.h | 10 + src/interface/gen-cpp2/storage_constants.cpp | 6 + src/interface/gen-cpp2/storage_constants.h | 19 + src/interface/gen-cpp2/storage_data.cpp | 1243 + src/interface/gen-cpp2/storage_data.h | 519 + .../gen-cpp2/storage_for_each_field.h | 721 + src/interface/gen-cpp2/storage_metadata.cpp | 2527 ++ src/interface/gen-cpp2/storage_metadata.h | 464 + src/interface/gen-cpp2/storage_types.cpp | 8662 ++++ src/interface/gen-cpp2/storage_types.h | 15765 +++++++ src/interface/gen-cpp2/storage_types.tcc | 13521 ++++++ .../gen-cpp2/storage_types_custom_protocol.h | 20 + .../storage_visit_by_thrift_field_metadata.h | 1224 + src/interface/gen-cpp2/storage_visit_union.h | 18 + src/interface/gen-cpp2/storage_visitation.h | 11 + src/time/TimeConversion.cpp | 97 + 208 files changed, 226796 insertions(+), 106 deletions(-) create mode 100644 cmake/CPackage.cmake create mode 100644 cmake/ClangTidy.cmake create mode 100644 cmake/FindBreakpad.cmake create mode 100644 cmake/FindBzip2.cmake create mode 100644 cmake/FindDoubleConversion.cmake create mode 100644 cmake/FindFatal.cmake create mode 100644 cmake/FindFbthrift.cmake create mode 100644 cmake/FindFizz.cmake create mode 100644 cmake/FindFolly.cmake create mode 100644 cmake/FindGPERF.cmake create mode 100644 cmake/FindGflags.cmake create mode 100644 cmake/FindGlog.cmake create mode 100644 cmake/FindGoogletest.cmake create mode 100644 cmake/FindJemalloc.cmake create mode 100644 cmake/FindKrb5.cmake create mode 100644 cmake/FindLibevent.cmake create mode 100644 cmake/FindLibunwind.cmake create mode 100644 cmake/FindMstch.cmake create mode 100644 cmake/FindNCURSES.cmake create mode 100644 cmake/FindPCHSupport.cmake create mode 100644 cmake/FindProxygen.cmake create mode 100644 cmake/FindReadline.cmake create mode 100644 cmake/FindRocksdb.cmake create mode 100644 cmake/FindSnappy.cmake create mode 100644 cmake/FindSodium.cmake create mode 100644 cmake/FindWangle.cmake create mode 100644 cmake/FindZstd.cmake create mode 100644 cmake/ThriftGenerate.cmake create mode 100644 cmake/nebula/ABIConfig.cmake create mode 100644 cmake/nebula/CcacheConfig.cmake create mode 100644 cmake/nebula/GeneralCMakeConfig.cmake create mode 100644 cmake/nebula/GeneralCMakeOptions.cmake create mode 100644 cmake/nebula/GeneralCompilerConfig.cmake create mode 100644 cmake/nebula/GitHooksConfig.cmake create mode 100644 cmake/nebula/GitInfoConfig.cmake create mode 100644 cmake/nebula/InstallThirdParty.cmake create mode 100644 cmake/nebula/LinkerConfig.cmake create mode 100644 cmake/nebula/MakeBisonRelocatable.cmake create mode 100644 cmake/nebula/NebulaCMakeMacros.cmake create mode 100644 cmake/nebula/NebulaCustomTargets.cmake create mode 100644 cmake/nebula/PlatformCheck.cmake create mode 100644 cmake/nebula/SanitizerConfig.cmake create mode 100644 cmake/nebula/ThirdPartyConfig.cmake create mode 100755 gen-interface.sh create mode 100644 include/common/datatypes/CommonCpp2Ops.h create mode 100644 include/common/datatypes/DataSet.h create mode 100644 include/common/datatypes/DataSetOps-inl.h create mode 100644 include/common/datatypes/Date.h create mode 100644 include/common/datatypes/DateOps-inl.h create mode 100644 include/common/datatypes/Edge.h create mode 100644 include/common/datatypes/EdgeOps-inl.h create mode 100644 include/common/datatypes/Geography.h create mode 100644 include/common/datatypes/GeographyOps-inl.h create mode 100644 include/common/datatypes/HostAddr.h create mode 100644 include/common/datatypes/HostAddrOps-inl.h create mode 100644 include/common/datatypes/KeyValue.h create mode 100644 include/common/datatypes/KeyValueOps-inl.h create mode 100644 include/common/datatypes/List.h create mode 100644 include/common/datatypes/ListOps-inl.h create mode 100644 include/common/datatypes/Map.h create mode 100644 include/common/datatypes/MapOps-inl.h create mode 100644 include/common/datatypes/Path.h create mode 100644 include/common/datatypes/PathOps-inl.h create mode 100644 include/common/datatypes/Set.h create mode 100644 include/common/datatypes/SetOps-inl.h create mode 100644 include/common/datatypes/Value.h create mode 100644 include/common/datatypes/ValueOps-inl.h create mode 100644 include/common/datatypes/Vertex.h create mode 100644 include/common/datatypes/VertexOps-inl.h create mode 100644 include/common/graph/AuthResponseOps-inl.h create mode 100644 include/common/graph/ExecutionResponseOps-inl.h create mode 100644 include/common/graph/GraphCpp2Ops.h create mode 100644 include/common/graph/PairOps-inl.h create mode 100644 include/common/graph/PlanDescriptionOps-inl.h create mode 100644 include/common/graph/PlanNodeBranchInfoOps-inl.h create mode 100644 include/common/graph/PlanNodeDescriptionOps-inl.h create mode 100644 include/common/graph/ProfilingStatsOps-inl.h create mode 100644 include/common/graph/Response.h create mode 100644 include/common/thrift/ThriftCpp2OpsHelper.h create mode 100644 include/common/thrift/ThriftTypes.h create mode 100644 include/common/time/TimeConversion.h create mode 100644 include/common/utils/utils.h create mode 100644 src/datatypes/Date.cpp create mode 100644 src/datatypes/Edge.cpp create mode 100644 src/datatypes/Geography.cpp create mode 100644 src/datatypes/HostAddr.cpp create mode 100644 src/datatypes/List.cpp create mode 100644 src/datatypes/Map.cpp create mode 100644 src/datatypes/Path.cpp create mode 100644 src/datatypes/Set.cpp create mode 100644 src/datatypes/Value.cpp create mode 100644 src/datatypes/Vertex.cpp create mode 100644 src/graph/Response.cpp create mode 100644 src/interface/CMakeLists.txt create mode 100644 src/interface/gen-cpp2/GeneralStorageService.cpp create mode 100644 src/interface/gen-cpp2/GeneralStorageService.h create mode 100644 src/interface/gen-cpp2/GeneralStorageService.tcc create mode 100644 src/interface/gen-cpp2/GeneralStorageServiceAsyncClient.cpp create mode 100644 src/interface/gen-cpp2/GeneralStorageServiceAsyncClient.h create mode 100644 src/interface/gen-cpp2/GeneralStorageService_custom_protocol.h create mode 100644 src/interface/gen-cpp2/GeneralStorageService_processmap_binary.cpp create mode 100644 src/interface/gen-cpp2/GeneralStorageService_processmap_compact.cpp create mode 100644 src/interface/gen-cpp2/GraphService.cpp create mode 100644 src/interface/gen-cpp2/GraphService.h create mode 100644 src/interface/gen-cpp2/GraphService.tcc create mode 100644 src/interface/gen-cpp2/GraphServiceAsyncClient.cpp create mode 100644 src/interface/gen-cpp2/GraphServiceAsyncClient.h create mode 100644 src/interface/gen-cpp2/GraphService_custom_protocol.h create mode 100644 src/interface/gen-cpp2/GraphService_processmap_binary.cpp create mode 100644 src/interface/gen-cpp2/GraphService_processmap_compact.cpp create mode 100644 src/interface/gen-cpp2/GraphStorageService.cpp create mode 100644 src/interface/gen-cpp2/GraphStorageService.h create mode 100644 src/interface/gen-cpp2/GraphStorageService.tcc create mode 100644 src/interface/gen-cpp2/GraphStorageServiceAsyncClient.cpp create mode 100644 src/interface/gen-cpp2/GraphStorageServiceAsyncClient.h create mode 100644 src/interface/gen-cpp2/GraphStorageService_custom_protocol.h create mode 100644 src/interface/gen-cpp2/GraphStorageService_processmap_binary.cpp create mode 100644 src/interface/gen-cpp2/GraphStorageService_processmap_compact.cpp create mode 100644 src/interface/gen-cpp2/InternalStorageService.cpp create mode 100644 src/interface/gen-cpp2/InternalStorageService.h create mode 100644 src/interface/gen-cpp2/InternalStorageService.tcc create mode 100644 src/interface/gen-cpp2/InternalStorageServiceAsyncClient.cpp create mode 100644 src/interface/gen-cpp2/InternalStorageServiceAsyncClient.h create mode 100644 src/interface/gen-cpp2/InternalStorageService_custom_protocol.h create mode 100644 src/interface/gen-cpp2/InternalStorageService_processmap_binary.cpp create mode 100644 src/interface/gen-cpp2/InternalStorageService_processmap_compact.cpp create mode 100644 src/interface/gen-cpp2/MetaService.cpp create mode 100644 src/interface/gen-cpp2/MetaService.h create mode 100644 src/interface/gen-cpp2/MetaService.tcc create mode 100644 src/interface/gen-cpp2/MetaServiceAsyncClient.cpp create mode 100644 src/interface/gen-cpp2/MetaServiceAsyncClient.h create mode 100644 src/interface/gen-cpp2/MetaService_custom_protocol.h create mode 100644 src/interface/gen-cpp2/MetaService_processmap_binary.cpp create mode 100644 src/interface/gen-cpp2/MetaService_processmap_compact.cpp create mode 100644 src/interface/gen-cpp2/StorageAdminService.cpp create mode 100644 src/interface/gen-cpp2/StorageAdminService.h create mode 100644 src/interface/gen-cpp2/StorageAdminService.tcc create mode 100644 src/interface/gen-cpp2/StorageAdminServiceAsyncClient.cpp create mode 100644 src/interface/gen-cpp2/StorageAdminServiceAsyncClient.h create mode 100644 src/interface/gen-cpp2/StorageAdminService_custom_protocol.h create mode 100644 src/interface/gen-cpp2/StorageAdminService_processmap_binary.cpp create mode 100644 src/interface/gen-cpp2/StorageAdminService_processmap_compact.cpp create mode 100644 src/interface/gen-cpp2/common_constants.cpp create mode 100644 src/interface/gen-cpp2/common_constants.h create mode 100644 src/interface/gen-cpp2/common_data.cpp create mode 100644 src/interface/gen-cpp2/common_data.h create mode 100644 src/interface/gen-cpp2/common_for_each_field.h create mode 100644 src/interface/gen-cpp2/common_metadata.cpp create mode 100644 src/interface/gen-cpp2/common_metadata.h create mode 100644 src/interface/gen-cpp2/common_types.cpp create mode 100644 src/interface/gen-cpp2/common_types.h create mode 100644 src/interface/gen-cpp2/common_types.tcc create mode 100644 src/interface/gen-cpp2/common_types_custom_protocol.h create mode 100644 src/interface/gen-cpp2/common_visit_by_thrift_field_metadata.h create mode 100644 src/interface/gen-cpp2/common_visit_union.h create mode 100644 src/interface/gen-cpp2/common_visitation.h create mode 100644 src/interface/gen-cpp2/graph_constants.cpp create mode 100644 src/interface/gen-cpp2/graph_constants.h create mode 100644 src/interface/gen-cpp2/graph_data.cpp create mode 100644 src/interface/gen-cpp2/graph_data.h create mode 100644 src/interface/gen-cpp2/graph_for_each_field.h create mode 100644 src/interface/gen-cpp2/graph_metadata.cpp create mode 100644 src/interface/gen-cpp2/graph_metadata.h create mode 100644 src/interface/gen-cpp2/graph_types.cpp create mode 100644 src/interface/gen-cpp2/graph_types.h create mode 100644 src/interface/gen-cpp2/graph_types.tcc create mode 100644 src/interface/gen-cpp2/graph_types_custom_protocol.h create mode 100644 src/interface/gen-cpp2/graph_visit_by_thrift_field_metadata.h create mode 100644 src/interface/gen-cpp2/graph_visit_union.h create mode 100644 src/interface/gen-cpp2/graph_visitation.h create mode 100644 src/interface/gen-cpp2/meta_constants.cpp create mode 100644 src/interface/gen-cpp2/meta_constants.h create mode 100644 src/interface/gen-cpp2/meta_data.cpp create mode 100644 src/interface/gen-cpp2/meta_data.h create mode 100644 src/interface/gen-cpp2/meta_for_each_field.h create mode 100644 src/interface/gen-cpp2/meta_metadata.cpp create mode 100644 src/interface/gen-cpp2/meta_metadata.h create mode 100644 src/interface/gen-cpp2/meta_types.cpp create mode 100644 src/interface/gen-cpp2/meta_types.h create mode 100644 src/interface/gen-cpp2/meta_types.tcc create mode 100644 src/interface/gen-cpp2/meta_types_custom_protocol.h create mode 100644 src/interface/gen-cpp2/meta_visit_by_thrift_field_metadata.h create mode 100644 src/interface/gen-cpp2/meta_visit_union.h create mode 100644 src/interface/gen-cpp2/meta_visitation.h create mode 100644 src/interface/gen-cpp2/storage_constants.cpp create mode 100644 src/interface/gen-cpp2/storage_constants.h create mode 100644 src/interface/gen-cpp2/storage_data.cpp create mode 100644 src/interface/gen-cpp2/storage_data.h create mode 100644 src/interface/gen-cpp2/storage_for_each_field.h create mode 100644 src/interface/gen-cpp2/storage_metadata.cpp create mode 100644 src/interface/gen-cpp2/storage_metadata.h create mode 100644 src/interface/gen-cpp2/storage_types.cpp create mode 100644 src/interface/gen-cpp2/storage_types.h create mode 100644 src/interface/gen-cpp2/storage_types.tcc create mode 100644 src/interface/gen-cpp2/storage_types_custom_protocol.h create mode 100644 src/interface/gen-cpp2/storage_visit_by_thrift_field_metadata.h create mode 100644 src/interface/gen-cpp2/storage_visit_union.h create mode 100644 src/interface/gen-cpp2/storage_visitation.h create mode 100644 src/time/TimeConversion.cpp diff --git a/.linters/cpp/hooks/pre-commit.sh b/.linters/cpp/hooks/pre-commit.sh index bdac363a..2bed2859 100755 --- a/.linters/cpp/hooks/pre-commit.sh +++ b/.linters/cpp/hooks/pre-commit.sh @@ -16,7 +16,7 @@ if [ $# -eq 0 ];then echo "You have unstaged changes, please stage or stash them first." exit 1 fi - CHECK_FILES=$(git diff --name-only --diff-filter=ACMRTUXB HEAD | egrep '.*\.cpp$|.*\.h$|.*\.inl$' | grep -v 'com_vesoft_client_NativeClient.h' | grep -v 'com_vesoft_nebula_NebulaCodec.h') + CHECK_FILES=$(git diff --name-only --diff-filter=ACMRTUXB HEAD | egrep '.*\.cpp$|.*\.h$|.*\.inl$' | grep -v 'com_vesoft_client_NativeClient.h' | grep -v 'com_vesoft_nebula_NebulaCodec.h' | grep -v 'interface') else CHECK_FILES=$(find $@ -not \( -path src/CMakeFiles -prune \) \ -not \( -path src/interface/gen-cpp2 -prune \) \ diff --git a/CMakeLists.txt b/CMakeLists.txt index 1dbbacc1..0cc561b9 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -31,43 +31,7 @@ option(DISABLE_CLONE_COMMON "Automatically disable clone common module" OFF) add_definitions(-DNEBULA_HOME=${CMAKE_SOURCE_DIR}) list(APPEND CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR}/cmake) - -# Submodules -if("${NEBULA_COMMON_REPO_URL}" STREQUAL "") - SET(NEBULA_COMMON_REPO_URL "https://github.com/vesoft-inc/nebula-common.git") -endif() - -if("${NEBULA_COMMON_REPO_TAG}" STREQUAL "") - SET(NEBULA_COMMON_REPO_TAG "master") -endif() - -include(FetchModule) -if(NOT NEBULA_COMMON_SOURCE_DIR) - if (NOT ${DISABLE_CLONE_COMMON}) - nebula_fetch_module( - NAME - common - URL - ${NEBULA_COMMON_REPO_URL} - TAG - ${NEBULA_COMMON_REPO_TAG} - UPDATE - ${ENABLE_MODULE_UPDATE} - ) - endif() - set(nebula_common_source_dir ${CMAKE_SOURCE_DIR}/modules/common) - set(nebula_common_build_dir ${CMAKE_BINARY_DIR}/modules/common) -else() - set(nebula_common_source_dir ${NEBULA_COMMON_SOURCE_DIR}) - if(NOT NEBULA_COMMON_BUILD_DIR) - set(nebula_common_build_dir ${CMAKE_BINARY_DIR}/modules/common) - else() - set(nebula_common_build_dir ${NEBULA_COMMON_BUILD_DIR}) - endif() -endif() - -list(APPEND CMAKE_MODULE_PATH ${nebula_common_source_dir}/cmake) -list(APPEND CMAKE_MODULE_PATH ${nebula_common_source_dir}/cmake/nebula) +list(APPEND CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR}/cmake/nebula) include(PlatformCheck) include(NebulaCMakeMacros) @@ -82,19 +46,9 @@ include(SanitizerConfig) include(GitHooksConfig) include(GitInfoConfig) include(NebulaCustomTargets) -include(ConfigNebulaCommon) set(ENABLE_PIC ON FORCE) set(ENABLE_JEMALLOC OFF FORCE) -config_nebula_common( - SOURCE_DIR ${nebula_common_source_dir} - BUILD_DIR ${nebula_common_build_dir} -) - -add_custom_target( - clean-modules - DEPENDS clean-common -) include(GNUInstallDirs) @@ -111,10 +65,6 @@ macro(nebula_add_library name type) APPEND FILE ${CMAKE_BINARY_DIR}/${PACKAGE_NAME}-config.cmake ) - add_dependencies( - ${name} - common_project - ) endmacro() nebula_add_shared_linker_flag(-static-libstdc++) @@ -132,31 +82,10 @@ install( PATTERN ".gitkeep" EXCLUDE ) -# resuse the datatypes in common -install(DIRECTORY ${nebula_common_source_dir}/src/common/datatypes - DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/common - FILES_MATCHING PATTERN "*.h") - -# reuse the response of graph in common -install(DIRECTORY ${nebula_common_source_dir}/src/common/graph - DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/common - FILES_MATCHING PATTERN "*.h") - -# reuse the time utils in common -install(DIRECTORY ${nebula_common_source_dir}/src/common/time - DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/common - FILES_MATCHING PATTERN "TimeConversion.h") - -# reuse the thrift types in common -install( - FILES - ${nebula_common_source_dir}/src/common/thrift/ThriftTypes.h - PERMISSIONS - OWNER_WRITE OWNER_READ - GROUP_READ - WORLD_READ - DESTINATION - ${CMAKE_INSTALL_INCLUDEDIR}/common/thrift +add_custom_target( + format + COMMAND "find" "include" "src/client" "src/datatypes" "src/time" "src/graph" "-type" "f" "\\(" "-iname" "\\*.h" "-o" "-iname" "\\*.cpp" "\\)" "|" "xargs" "clang-format" "-i" + WORKING_DIRECTORY ${CMAKE_SOURCE_DIR} ) include(CPackage) diff --git a/cmake/CPackage.cmake b/cmake/CPackage.cmake new file mode 100644 index 00000000..b26eda90 --- /dev/null +++ b/cmake/CPackage.cmake @@ -0,0 +1,170 @@ +# Copyright (c) 2020 vesoft inc. All rights reserved. +# +# This source code is licensed under Apache 2.0 License, +# attached with Common Clause Condition 1.0, found in the LICENSES directory. +# + + +# Used to package into deb or RPM files +macro(package to_one name home_page scripts_dir) + set(CPACK_PACKAGE_DESCRIPTION ${name}) + set(CPACK_PACKAGE_CONTACT ${name}) + set(CPACK_PACKAGE_VERSION ${NEBULA_BUILD_VERSION}) + set(CPACK_RPM_PACKAGE_LICENSE "Apache 2.0 + Common Clause 1.0") + set(CPACK_PACKAGE_NAME ${name}) + # set(CPACK_SET_DESTDIR TRUE) + set(CPACK_PACKAGE_RELOCATABLE ON) + set(CPACK_INSTALL_PREFIX ${CMAKE_INSTALL_PREFIX}) + set(CPACK_PACKAGING_INSTALL_PREFIX ${CMAKE_INSTALL_PREFIX}) + if (EXISTS "/etc/redhat-release") + if(ENABLE_PACKAGE_TAR) + set(CPACK_GENERATOR "TGZ") + else() + set(CPACK_GENERATOR "RPM") + endif() + file (STRINGS "/etc/redhat-release" SYSTEM_NAME) + if (${SYSTEM_NAME} MATCHES "CentOS") + set(HOST_SYSTEM_NAME "el") + execute_process( + COMMAND echo ${SYSTEM_NAME} + COMMAND tr -dc "0-9." + COMMAND cut -d "." -f1 + OUTPUT_VARIABLE HOST_SYSTEM_VER + OUTPUT_STRIP_TRAILING_WHITESPACE + ) + string(CONCAT HOST_SYSTEM_VER ${HOST_SYSTEM_NAME} ${HOST_SYSTEM_VER}) + elseif (${SYSTEM_NAME} MATCHES "Fedora") + set(HOST_SYSTEM_NAME "fc") + execute_process( + COMMAND echo ${SYSTEM_NAME} + COMMAND cut -d " " -f3 + OUTPUT_VARIABLE HOST_SYSTEM_VER + OUTPUT_STRIP_TRAILING_WHITESPACE + ) + string(CONCAT HOST_SYSTEM_VER ${HOST_SYSTEM_NAME} ${HOST_SYSTEM_VER}) + else() + set(HOST_SYSTEM_VER "Unknown") + endif() + elseif (EXISTS "/etc/lsb-release") + if(ENABLE_PACKAGE_TAR) + set(CPACK_GENERATOR "TGZ") + else() + set(CPACK_GENERATOR "DEB") + endif() + file (STRINGS "/etc/lsb-release" SYSTEM_NAME) + execute_process( + COMMAND echo "${SYSTEM_NAME}" + COMMAND cut -d ";" -f 1 + COMMAND cut -d "=" -f 2 + OUTPUT_VARIABLE HOST_SYSTEM_NAME + OUTPUT_STRIP_TRAILING_WHITESPACE + ) + execute_process( + COMMAND echo "${SYSTEM_NAME}" + COMMAND cut -d ";" -f 2 + COMMAND cut -d "=" -f 2 + OUTPUT_VARIABLE HOST_SYSTEM_VER + OUTPUT_STRIP_TRAILING_WHITESPACE + ) + string(REPLACE "." "" HOST_SYSTEM_VER ${HOST_SYSTEM_VER}) + if (${HOST_SYSTEM_NAME} MATCHES "Ubuntu") + string(CONCAT HOST_SYSTEM_VER "ubuntu" ${HOST_SYSTEM_VER}) + # the ubuntu need to modify the architecture name + if (${CMAKE_HOST_SYSTEM_PROCESSOR} MATCHES "x86_64") + set(CMAKE_HOST_SYSTEM_PROCESSOR "amd64") + endif() + # Adapt the Kylin system + elseif (${HOST_SYSTEM_NAME} MATCHES "Kylin" AND ${CMAKE_HOST_SYSTEM_PROCESSOR} MATCHES "aarch64") + string(CONCAT HOST_SYSTEM_VER ${HOST_SYSTEM_NAME} ${HOST_SYSTEM_VER}) + set(CMAKE_HOST_SYSTEM_PROCESSOR "arm64") + endif() + elseif (EXISTS "/etc/issue") + file (STRINGS "/etc/issue" SYSTEM_NAME) + execute_process( + COMMAND echo "${SYSTEM_NAME}" + COMMAND sed -n "1p" + COMMAND cut -d " " -f 1 + OUTPUT_VARIABLE HOST_SYSTEM_NAME + OUTPUT_STRIP_TRAILING_WHITESPACE + ) + execute_process( + COMMAND echo "${SYSTEM_NAME}" + COMMAND sed -n "1p" + COMMAND cut -d " " -f 3 + OUTPUT_VARIABLE HOST_SYSTEM_VER + OUTPUT_STRIP_TRAILING_WHITESPACE + ) + if (${HOST_SYSTEM_NAME} MATCHES "Debian") + execute_process( + COMMAND echo "${SYSTEM_NAME}" + COMMAND sed -n "1p" + COMMAND cut -d " " -f 3 + OUTPUT_VARIABLE HOST_SYSTEM_VER + OUTPUT_STRIP_TRAILING_WHITESPACE + ) + if(ENABLE_PACKAGE_TAR) + set(CPACK_GENERATOR "TGZ") + else() + set(CPACK_GENERATOR "DEB") + endif() + # Adapt the NeoKylin system + elseif (${HOST_SYSTEM_NAME} MATCHES "NeoKylin" AND ${CMAKE_HOST_SYSTEM_PROCESSOR} MATCHES "mips64") + execute_process( + COMMAND echo "${SYSTEM_NAME}" + COMMAND sed -n "1p" + COMMAND cut -d " " -f 4 + OUTPUT_VARIABLE HOST_SYSTEM_VER + OUTPUT_STRIP_TRAILING_WHITESPACE + ) + set(CMAKE_HOST_SYSTEM_PROCESSOR "mips64el") + if(ENABLE_PACKAGE_TAR) + set(CPACK_GENERATOR "TGZ") + else() + set(CPACK_GENERATOR "RPM") + endif() + endif() + string(CONCAT HOST_SYSTEM_VER ${HOST_SYSTEM_NAME} ${HOST_SYSTEM_VER}) + set(CMAKE_HOST_SYSTEM_PROCESSOR "mips64el") + else() + set(HOST_SYSTEM_VER "Unknown") + endif() + + message(STATUS "HOST_SYSTEM_NAME is ${HOST_SYSTEM_NAME}") + message(STATUS "HOST_SYSTEM_VER is ${HOST_SYSTEM_VER}") + message(STATUS "CPACK_GENERATOR is ${CPACK_GENERATOR}") + message(STATUS "CMAKE_HOST_SYSTEM_PROCESSOR is ${CMAKE_HOST_SYSTEM_PROCESSOR}") + + set(CPACK_PACKAGE_FILE_NAME ${CPACK_PACKAGE_NAME}-${CPACK_PACKAGE_VERSION}.${HOST_SYSTEM_VER}.${CMAKE_HOST_SYSTEM_PROCESSOR}) + if (${to_one}) + set(CPACK_COMPONENTS_GROUPING ALL_COMPONENTS_IN_ONE) + else () + set(CPACK_COMPONENTS_GROUPING ONE_PER_GROUP) + endif() + + set(CPACK_DEB_COMPONENT_INSTALL YES) + set(CPACK_DEBIAN_PACKAGE_ARCHITECTURE ${CMAKE_HOST_SYSTEM_PROCESSOR}) + set(CPACK_DEBIAN_PACKAGE_HOMEPAGE ${home_page}) + set(CPACK_DEBIAN_PACKAGE_CONTROL_EXTRA ${scripts_dir}/postinst) + + set(CPACK_RPM_SPEC_MORE_DEFINE "%define debug_package %{nil} + %define __os_install_post %{nil}") + set(CPACK_RPM_COMPONENT_INSTALL YES) + set(CPACK_RPM_PACKAGE_ARCHITECTURE ${CMAKE_HOST_SYSTEM_PROCESSOR}) + set(CPACK_RPM_PACKAGE_URL ${home_page}) + set(CPACK_RPM_POST_INSTALL_SCRIPT_FILE ${scripts_dir}/rpm_postinst) + set(CPACK_RPM_EXCLUDE_FROM_AUTO_FILELIST_ADDITION /usr/local) + set(CPACK_RPM_PACKAGE_RELOCATABLE ON) + + include(CPack) + + cpack_add_component(common GROUP common) + cpack_add_component(graph GROUP graph DEPENDS common) + cpack_add_component(storage GROUP storage DEPENDS common) + cpack_add_component(meta GROUP meta DEPENDS common) + cpack_add_component(tool GROUP tool) + cpack_add_component_group(common) + cpack_add_component_group(graph) + cpack_add_component_group(storage) + cpack_add_component_group(meta) + cpack_add_component_group(tool) +endmacro() diff --git a/cmake/ClangTidy.cmake b/cmake/ClangTidy.cmake new file mode 100644 index 00000000..0abca6b4 --- /dev/null +++ b/cmake/ClangTidy.cmake @@ -0,0 +1,13 @@ +if (ENABLE_CLANG_TIDY) + if (${CMAKE_VERSION} VERSION_LESS "3.6.0") + message(FATAL_ERROR "clang-tidy requires CMake version at least 3.6.") + endif() + + find_program (CLANG_TIDY_PATH NAMES "clang-tidy") + if (CLANG_TIDY_PATH) + message(STATUS "Using clang-tidy: ${CLANG_TIDY_PATH}.") + set (CMAKE_CXX_CLANG_TIDY ${CLANG_TIDY_PATH} --config=) + else () + message(STATUS "clang-tidy is not found.") + endif () +endif () diff --git a/cmake/FetchModule.cmake b/cmake/FetchModule.cmake index 78ecd92d..f9dd79b5 100644 --- a/cmake/FetchModule.cmake +++ b/cmake/FetchModule.cmake @@ -7,16 +7,15 @@ find_package(Git) macro(nebula_fetch_module) cmake_parse_arguments( - module # - "" # - "URL;TAG;UPDATE;NAME" # - "" # + module # + "" # + "URL;TAG;UPDATE;NAME;CHECKOUT" # + "" # ${ARGN} ) set(module_dir ${CMAKE_SOURCE_DIR}/modules/${module_NAME}) if(NOT EXISTS ${module_dir}/.git) - message(STATUS "Cloning from ${module_URL}") - message(STATUS "Execute ${GIT_EXECUTABLE} clone --single-branch --branch ${module_TAG} ${module_URL} ${module_dir}") + message(STATUS "Cloning from ${module_URL}:${module_TAG}") execute_process( COMMAND ${GIT_EXECUTABLE} clone @@ -29,15 +28,49 @@ macro(nebula_fetch_module) if(NOT ${fetch_status} EQUAL 0) message(FATAL_ERROR "Cloning failed") endif() - elseif(${module_UPDATE}) - message(STATUS "Updating from ${module_URL}") - execute_process( - COMMAND ${GIT_EXECUTABLE} pull - WORKING_DIRECTORY ${module_dir} - RESULT_VARIABLE fetch_status - ) - if(NOT ${fetch_status} EQUAL 0) - message(FATAL_ERROR "Updating failed") + else() + if (${module_CHECKOUT}) + execute_process( + COMMAND ${GIT_EXECUTABLE} rev-parse --abbrev-ref HEAD + WORKING_DIRECTORY ${module_dir} + OUTPUT_VARIABLE branch_name + ) + string(REPLACE "\n" "" branch_name "${branch_name}") + if(NOT ${branch_name} STREQUAL ${module_TAG}) + message(STATUS "The branch of ${module_NAME} is ${branch_name}, need to change to ${module_TAG}") + execute_process( + COMMAND ${GIT_EXECUTABLE} remote set-branches origin --add ${module_TAG} + WORKING_DIRECTORY ${module_dir} + ) + execute_process( + COMMAND ${GIT_EXECUTABLE} config remote.origin.fetch + WORKING_DIRECTORY ${module_dir} + ) + execute_process( + COMMAND ${GIT_EXECUTABLE} fetch + WORKING_DIRECTORY ${module_dir} + ) + execute_process( + COMMAND ${GIT_EXECUTABLE} checkout ${module_TAG} + WORKING_DIRECTORY ${module_dir} + RESULT_VARIABLE checkout_status + ERROR_VARIABLE error_msg + ) + if(NOT ${checkout_status} EQUAL 0) + message(FATAL_ERROR "Checkout to branch ${module_TAG} failed: ${error_msg}, error_code: ${checkout_status}") + endif() + endif() + endif() + if(${module_UPDATE}) + message(STATUS "Updating from ${module_URL}") + execute_process( + COMMAND ${GIT_EXECUTABLE} pull + WORKING_DIRECTORY ${module_dir} + RESULT_VARIABLE fetch_status + ) + if(NOT ${fetch_status} EQUAL 0) + message(FATAL_ERROR "Updating failed") + endif() endif() endif() endmacro() diff --git a/cmake/FindBreakpad.cmake b/cmake/FindBreakpad.cmake new file mode 100644 index 00000000..65136384 --- /dev/null +++ b/cmake/FindBreakpad.cmake @@ -0,0 +1,33 @@ +# - Try to find Breakpad includes dirs and libraries +# +# Usage of this module as follows: +# +# find_package(Breakpad) +# +# Variables used by this module, they can change the default behaviour and need +# to be set before calling find_package: +# +# Variables defined by this module: +# +# Breakpad_FOUND System has breakpad, include and lib dirs found +# Breakpad_INCLUDE_DIR The breakpad includes directories. +# Breakpad_LIBRARY The breakpad library. + +find_path(Breakpad_INCLUDE_DIR NAMES breakpad) +find_library(Breakpad_LIBRARY NAMES libbreakpad_client.a) + +message(STATUS "BREAKPAD: ${Breakpad_INCLUDE_DIR}") + +if(Breakpad_INCLUDE_DIR AND Breakpad_LIBRARY) + set(Breakpad_FOUND TRUE) + mark_as_advanced( + Breakpad_INCLUDE_DIR + Breakpad_LIBRARY + ) +endif() + +if(NOT Breakpad_FOUND) + message(FATAL_ERROR "Breakpad doesn't exist") +endif() + + diff --git a/cmake/FindBzip2.cmake b/cmake/FindBzip2.cmake new file mode 100644 index 00000000..70f944a3 --- /dev/null +++ b/cmake/FindBzip2.cmake @@ -0,0 +1,34 @@ +# - Try to find Bzip2 includes dirs and libraries +# +# Usage of this module as follows: +# +# find_package(Bzip2) +# +# Variables used by this module, they can change the default behaviour and need +# to be set before calling find_package: +# +# Variables defined by this module: +# +# Bzip2_FOUND System has bzip2, include and lib dirs found. +# Bzip2_INCLUDE_DIR The bzip2 includes directories. +# Bzip2_LIBRARY The bzip2 library. +# Bzip2_BIN The bzip2 binary. + +find_path(Bzip2_INCLUDE_DIR NAMES bzlib.h) +find_library(Bzip2_LIBRARY NAMES libbz2.a) +find_program(Bzip2_BIN NAMES bzip2) + +if(Bzip2_INCLUDE_DIR AND Bzip2_LIBRARY AND Bzip2_BIN) + set(Bzip2_FOUND TRUE) + mark_as_advanced( + Bzip2_INCLUDE_DIR + Bzip2_LIBRARY + Bzip2_BIN + ) +endif() + +if(NOT Bzip2_FOUND) + message(FATAL_ERROR "Bzip2 doesn't exist") +endif() + + diff --git a/cmake/FindDoubleConversion.cmake b/cmake/FindDoubleConversion.cmake new file mode 100644 index 00000000..cdfc87fc --- /dev/null +++ b/cmake/FindDoubleConversion.cmake @@ -0,0 +1,30 @@ +# - Try to find libdouble-conversion includes dirs and libraries +# +# Usage of this module as follows: +# +# find_package(DoubleConversion) +# +# Variables used by this module, they can change the default behaviour and need +# to be set before calling find_package: +# +# Variables defined by this module: +# +# DoubleConversion_FOUND System has double-conversion, include and lib dirs found +# DoubleConversion_INCLUDE_DIR The double-conversion includes directories. +# DoubleConversion_LIBRARY The double-conversion library. + +find_path(DoubleConversion_INCLUDE_DIR NAMES double-conversion/double-conversion.h) +find_library(DoubleConversion_LIBRARY NAMES libdouble-conversion.a) + +if(DoubleConversion_INCLUDE_DIR AND DoubleConversion_LIBRARY) + set(DoubleConversion_FOUND TRUE) + mark_as_advanced( + DoubleConversion_INCLUDE_DIR + DoubleConversion_LIBRARY + ) +endif() + +if(NOT DoubleConversion_FOUND) + message(FATAL_ERROR "Double-conversion doesn't exist") +endif() + diff --git a/cmake/FindFatal.cmake b/cmake/FindFatal.cmake new file mode 100644 index 00000000..5b4e2870 --- /dev/null +++ b/cmake/FindFatal.cmake @@ -0,0 +1,27 @@ +# - Try to find Fatal includes dirs and libraries +# +# Usage of this module as follows: +# +# find_package(Fatal) +# +# Variables used by this module, they can change the default behaviour and need +# to be set before calling find_package: +# +# Variables defined by this module: +# +# Fatal_FOUND System has readline, include and lib dirs found +# Fatal_INCLUDE_DIR The readline includes directories. + +find_path(Fatal_INCLUDE_DIR NAMES fatal) + +if(Fatal_INCLUDE_DIR) + set(Fatal_FOUND TRUE) + mark_as_advanced( + Fatal_INCLUDE_DIR + ) +endif() + +if(NOT Fatal_FOUND) + message(FATAL_ERROR "Fatal doesn't exist") +endif() + diff --git a/cmake/FindFbthrift.cmake b/cmake/FindFbthrift.cmake new file mode 100644 index 00000000..0efd4e61 --- /dev/null +++ b/cmake/FindFbthrift.cmake @@ -0,0 +1,33 @@ +# - Try to find Fbthrift includes dirs and libraries +# +# Usage of this module as follows: +# +# find_package(Fbthrift) +# +# Variables used by this module, they can change the default behaviour and need +# to be set before calling find_package: +# +# Variables defined by this module: +# +# Fbthrift_FOUND System has fbthrift, thrift1 and include and lib dirs found. +# Fbthrift_INCLUDE_DIR The fbthrift includes directories. +# Fbthrift_LIBRARY The fbthrift library. +# Fbthrift_BIN The fbthrift binary. + +find_path(Fbthrift_INCLUDE_DIR NAMES thrift) +find_library(Fbthrift_LIBRARY NAMES libthriftcpp2.a) +find_program(Fbthrift_BIN NAMES thrift1) + +if(Fbthrift_INCLUDE_DIR AND Fbthrift_LIBRARY AND Fbthrift_BIN) + set(Fbthrift_FOUND TRUE) + mark_as_advanced( + Fbthrift_INCLUDE_DIR + Fbthrift_LIBRARY + Fbthrift_BIN + ) +endif() + +if(NOT Fbthrift_FOUND) + message(FATAL_ERROR "Fbthrift doesn't exist") +endif() + diff --git a/cmake/FindFizz.cmake b/cmake/FindFizz.cmake new file mode 100644 index 00000000..d044c71f --- /dev/null +++ b/cmake/FindFizz.cmake @@ -0,0 +1,30 @@ +# - Try to find Fizz includes dirs and libraries +# +# Usage of this module as follows: +# +# find_package(Fizz) +# +# Variables used by this module, they can change the default behaviour and need +# to be set before calling find_package: +# +# Variables defined by this module: +# +# Fizz_FOUND System has fizz, include and lib dirs found +# Fizz_INCLUDE_DIR The fizz includes directories. +# Fizz_LIBRARY The fizz library. + +find_path(Fizz_INCLUDE_DIR NAMES fizz) +find_library(Fizz_LIBRARY NAMES libfizz.a) + +if(Fizz_INCLUDE_DIR AND Fizz_LIBRARY) + set(Fizz_FOUND TRUE) + mark_as_advanced( + Fizz_INCLUDE_DIR + Fizz_LIBRARY + ) +endif() + +if(NOT Fizz_FOUND) + message(FATAL_ERROR "Fizz doesn't exist") +endif() + diff --git a/cmake/FindFolly.cmake b/cmake/FindFolly.cmake new file mode 100644 index 00000000..ba4e052b --- /dev/null +++ b/cmake/FindFolly.cmake @@ -0,0 +1,30 @@ +# - Try to find Folly includes dirs and libraries +# +# Usage of this module as follows: +# +# find_package(Folly) +# +# Variables used by this module, they can change the default behaviour and need +# to be set before calling find_package: +# +# Variables defined by this module: +# +# Folly_FOUND System has folly, include and lib dirs found +# Folly_INCLUDE_DIR The folly includes directories. +# Folly_LIBRARY The folly library. + +find_path(Folly_INCLUDE_DIR NAMES folly) +find_library(Folly_LIBRARY NAMES libfolly.a libfollybenchmark.a) + +if(Folly_INCLUDE_DIR AND Folly_LIBRARY) + set(Folly_FOUND TRUE) + mark_as_advanced( + Folly_INCLUDE_DIR + Folly_LIBRARY + ) +endif() + +if(NOT Folly_FOUND) + message(FATAL_ERROR "Folly doesn't exist") +endif() + diff --git a/cmake/FindGPERF.cmake b/cmake/FindGPERF.cmake new file mode 100644 index 00000000..e2e99cbf --- /dev/null +++ b/cmake/FindGPERF.cmake @@ -0,0 +1,61 @@ +# FindGPERF +# --------- +# +# Find ``gperf`` executable +# +# The module defines the following variables: +# +# ``GPERF_EXECUTABLE_DIR`` +# path to search the gperf binary +# +# ``GPERF_EXECUTABLE`` +# path to the ``gperf`` program +# +# ``GPERF_BIN_DIR`` +# path to the directory that holds ``gperf`` program +# +# ``GPERF_VERSION`` +# version of ``gperf`` +# +# ``GPERF_FOUND`` +# true if the program was found +# +# The minimum required version of ``gperf`` can be specified using the +# standard CMake syntax, e.g. ``find_package(GPERF 3.0)``. + +find_program(GPERF_EXECUTABLE + NAMES gperf + PATHS ${GPERF_EXECUTABLE_DIR} + DOC "path to the gperf executable") + +if(GPERF_EXECUTABLE) + # Extract the path + STRING(REGEX REPLACE "/gperf$" "" GPERF_BIN_DIR ${GPERF_EXECUTABLE}) + + # the gperf commands should be executed with the C locale, otherwise + # the message (which is parsed) may be translated + set(_gperf_SAVED_LC_ALL "$ENV{LC_ALL}") + set(ENV{LC_ALL} C) + + execute_process(COMMAND ${GPERF_EXECUTABLE} --version + OUTPUT_VARIABLE GPERF_version_output + ERROR_VARIABLE GPERF_version_error + RESULT_VARIABLE GPERF_version_result + OUTPUT_STRIP_TRAILING_WHITESPACE) + + set(ENV{LC_ALL} ${_gperf_SAVED_LC_ALL}) + + if(NOT ${GPERF_version_result} EQUAL 0) + message(SEND_ERROR "Command \"${GPERF_EXECUTABLE} --version\" failed with output:\n${GPERF_version_error}") + else() + if("${GPERF_version_output}" MATCHES "^GNU gperf ([^\n]+)") + set(GPERF_VERSION "${CMAKE_MATCH_1}") + endif() + endif() + +endif() +mark_as_advanced(GPERF_EXECUTABLE GPERF_BIN_DIR) + +include(FindPackageHandleStandardArgs) +FIND_PACKAGE_HANDLE_STANDARD_ARGS(GPERF REQUIRED_VARS GPERF_EXECUTABLE + VERSION_VAR GPERF_VERSION) diff --git a/cmake/FindGflags.cmake b/cmake/FindGflags.cmake new file mode 100644 index 00000000..144e1c09 --- /dev/null +++ b/cmake/FindGflags.cmake @@ -0,0 +1,30 @@ +# - Try to find Gflags includes dirs and libraries +# +# Usage of this module as follows: +# +# find_package(Gflags) +# +# Variables used by this module, they can change the default behaviour and need +# to be set before calling find_package: +# +# Variables defined by this module: +# +# Gflags_FOUND System has Gflags, include and lib dirs found +# Gflags_INCLUDE_DIR The Gflags includes directories. +# Gflags_LIBRARY The Gflags library. + +find_path(Gflags_INCLUDE_DIR NAMES gflags) +find_library(Gflags_LIBRARY NAMES libgflags.a) + +if(Gflags_INCLUDE_DIR AND Gflags_LIBRARY) + set(Gflags_FOUND TRUE) + mark_as_advanced( + Gflags_INCLUDE_DIR + Gflags_LIBRARY + ) +endif() + +if(NOT Gflags_FOUND) + message(FATAL_ERROR "Gflags doesn't exist") +endif() + diff --git a/cmake/FindGlog.cmake b/cmake/FindGlog.cmake new file mode 100644 index 00000000..53941832 --- /dev/null +++ b/cmake/FindGlog.cmake @@ -0,0 +1,30 @@ +# - Try to find Glog includes dirs and libraries +# +# Usage of this module as follows: +# +# find_package(Glog) +# +# Variables used by this module, they can change the default behaviour and need +# to be set before calling find_package: +# +# Variables defined by this module: +# +# Glog_FOUND System has Glog, include and lib dirs found +# Glog_INCLUDE_DIR The Glog includes directories. +# Glog_LIBRARY The Glog library. + +find_path(Glog_INCLUDE_DIR NAMES glog) +find_library(Glog_LIBRARY NAMES libglog.a) + +if(Glog_INCLUDE_DIR AND Glog_LIBRARY) + set(Glog_FOUND TRUE) + mark_as_advanced( + Glog_INCLUDE_DIR + Glog_LIBRARY + ) +endif() + +if(NOT Glog_FOUND) + message(FATAL_ERROR "Glog doesn't exist") +endif() + diff --git a/cmake/FindGoogletest.cmake b/cmake/FindGoogletest.cmake new file mode 100644 index 00000000..cb22c8d3 --- /dev/null +++ b/cmake/FindGoogletest.cmake @@ -0,0 +1,30 @@ +# - Try to find Googletest includes dirs and libraries +# +# Usage of this module as follows: +# +# find_package(Googletest) +# +# Variables used by this module, they can change the default behaviour and need +# to be set before calling find_package: +# +# Variables defined by this module: +# +# Googletest_FOUND System has Googletest, include and lib dirs found +# Googletest_INCLUDE_DIR The Googletest includes directories. +# Googletest_LIBRARY The Googletest library. + +find_path(Googletest_INCLUDE_DIR NAMES gmock gtest) +find_library(Googletest_LIBRARY NAMES libgmock.a libgmock_main.a libgtest.a libgtest_main.a) + +if(Googletest_INCLUDE_DIR AND Googletest_LIBRARY) + set(Googletest_FOUND TRUE) + mark_as_advanced( + Googletest_INCLUDE_DIR + Googletest_LIBRARY + ) +endif() + +if(NOT Googletest_FOUND) + message(FATAL_ERROR "Googletest doesn't exist") +endif() + diff --git a/cmake/FindJemalloc.cmake b/cmake/FindJemalloc.cmake new file mode 100644 index 00000000..e85a842f --- /dev/null +++ b/cmake/FindJemalloc.cmake @@ -0,0 +1,29 @@ +# - Try to find Jemalloc includes dirs and libraries +# +# Usage of this module as follows: +# +# find_package(Jemalloc) +# +# Variables used by this module, they can change the default behaviour and need +# to be set before calling find_package: +# +# Variables defined by this module: +# +# Jemalloc_FOUND System has Jemalloc, include and lib dirs found +# Jemalloc_INCLUDE_DIR The Jemalloc includes directories. +# Jemalloc_LIBRARY The Jemalloc library. + +find_path(Jemalloc_INCLUDE_DIR NAMES jemalloc) +find_library(Jemalloc_LIBRARY NAMES libjemalloc.a) + +if(Jemalloc_INCLUDE_DIR AND Jemalloc_LIBRARY) + set(Jemalloc_FOUND TRUE) + mark_as_advanced( + Jemalloc_INCLUDE_DIR + Jemalloc_LIBRARY + ) +endif() + +if(NOT Jemalloc_FOUND) + message(FATAL_ERROR "Jemalloc doesn't exist") +endif() diff --git a/cmake/FindKrb5.cmake b/cmake/FindKrb5.cmake new file mode 100644 index 00000000..0c064097 --- /dev/null +++ b/cmake/FindKrb5.cmake @@ -0,0 +1,169 @@ +# Original source: +# https://raw.githubusercontent.com/nfs-ganesha/nfs-ganesha/master/src/cmake/modules/FindKrb5.cmake +# +# - Find kerberos 5 +# Find the native Kerberos 5 headers and libraries. +# KRB5_INCLUDE_DIRS - where to find krb5.h, etc. +# KRB5_LIBRARY_DIRS - where to find krb5 libraries. +# KRB5_LIBRARIES - List of libraries when using kerberos 5. +# KRB5_CFLAGS - Required cflags for KRB5, such as -I +# KRB5_LINKFLAGS - Required link flags for KRB5 +# KRB5_FOUND - True if kerberos 5 found. +# KRB5 modules may be specified as components for this find module. +# Modules may be listed by running "krb5-config". Modules include: +# krb5 Kerberos 5 application +# gssapi GSSAPI application with Kerberos 5 bindings +# krb4 Kerberos 4 application +# kadm-client Kadmin client +# kadm-server Kadmin server +# kdb Application that accesses the kerberos database +# Typical usage: +# FIND_PACKAGE(KRB5 REQUIRED gssapi) + +# First find the config script from which to obtain other values. +IF(KRB5_PREFIX) + FIND_PROGRAM(KRB5_C_CONFIG NAMES krb5-config + PATHS ${KRB5_PREFIX}/bin + NO_SYSTEM_ENVIRONMENT_PATH + NO_DEFAULT_PATH + ) +ENDIF(KRB5_PREFIX) +FIND_PROGRAM(KRB5_C_CONFIG NAMES krb5-config) + +MESSAGE(STATUS "found krb5-config here ${KRB5_C_CONFIG}") + +# Check whether we found anything. +IF(KRB5_C_CONFIG) + SET(KRB5_FOUND 1) +ELSE(KRB5_C_CONFIG) + SET(KRB5_FOUND 0) +ENDIF(KRB5_C_CONFIG) + +# Lookup the include directories needed for the components requested. +IF(KRB5_FOUND) + # Use the newer EXECUTE_PROCESS command if it is available. + IF(COMMAND EXECUTE_PROCESS) + EXECUTE_PROCESS( + COMMAND ${KRB5_C_CONFIG} ${KRB5_FIND_COMPONENTS} --cflags + OUTPUT_VARIABLE KRB5_C_CONFIG_CFLAGS + OUTPUT_STRIP_TRAILING_WHITESPACE + RESULT_VARIABLE KRB5_C_CONFIG_RESULT + ) + ELSE(COMMAND EXECUTE_PROCESS) + EXEC_PROGRAM(${KRB5_C_CONFIG} ARGS "${KRB5_FIND_COMPONENTS} --cflags" + OUTPUT_VARIABLE KRB5_C_CONFIG_CFLAGS + RETURN_VALUE KRB5_C_CONFIG_RESULT + ) + ENDIF(COMMAND EXECUTE_PROCESS) + + # Parse the include flags. + IF("${KRB5_C_CONFIG_RESULT}" MATCHES "^0$") + SET(KRB5_CFLAGS ${KRB5_C_CONFIG_CFLAGS}) + + # Convert the compile flags to a CMake list. + STRING(REGEX REPLACE " +" ";" + KRB5_C_CONFIG_CFLAGS "${KRB5_C_CONFIG_CFLAGS}") + + # Look for -I options. + SET(KRB5_INCLUDE_DIRS) + FOREACH(flag ${KRB5_C_CONFIG_CFLAGS}) + IF("${flag}" MATCHES "^-I") + STRING(REGEX REPLACE "^-I" "" DIR "${flag}") + FILE(TO_CMAKE_PATH "${DIR}" DIR) + SET(KRB5_INCLUDE_DIRS ${KRB5_INCLUDE_DIRS} "${DIR}") + ENDIF("${flag}" MATCHES "^-I") + ENDFOREACH(flag) + ELSE("${KRB5_C_CONFIG_RESULT}" MATCHES "^0$") + MESSAGE("Error running ${KRB5_C_CONFIG}: [${KRB5_C_CONFIG_RESULT}]") + SET(KRB5_FOUND 0) + ENDIF("${KRB5_C_CONFIG_RESULT}" MATCHES "^0$") +ENDIF(KRB5_FOUND) + +IF(KRB5_PREFIX) + SET(KRB5_INCLUDE_DIRS "${KRB5_PREFIX}/include" ${KRB5_INCLUDE_DIRS}) +ENDIF(KRB5_PREFIX) + +# Lookup the libraries needed for the components requested. +IF(KRB5_FOUND) + # Use the newer EXECUTE_PROCESS command if it is available. + IF(COMMAND EXECUTE_PROCESS) + EXECUTE_PROCESS( + COMMAND ${KRB5_C_CONFIG} ${KRB5_FIND_COMPONENTS} --libs gssapi + OUTPUT_VARIABLE KRB5_C_CONFIG_LIBS + OUTPUT_STRIP_TRAILING_WHITESPACE + RESULT_VARIABLE KRB5_C_CONFIG_RESULT + ) + ELSE(COMMAND EXECUTE_PROCESS) + EXEC_PROGRAM(${KRB5_C_CONFIG} ARGS "${KRB5_FIND_COMPONENTS} --libs gssapi" + OUTPUT_VARIABLE KRB5_C_CONFIG_LIBS + RETURN_VALUE KRB5_C_CONFIG_RESULT + ) + ENDIF(COMMAND EXECUTE_PROCESS) + + # Parse the library names and directories. + IF("${KRB5_C_CONFIG_RESULT}" MATCHES "^0$") + SET(KRB5_LINKFLAGS ${KRB5_C_CONFIG_LIBS}) + + STRING(REGEX REPLACE " +" ";" + KRB5_C_CONFIG_LIBS "${KRB5_C_CONFIG_LIBS}") + + # Look for -L flags for directories and -l flags for library names. + SET(KRB5_LIBRARY_DIRS) + SET(KRB5_LIBRARY_NAMES) + FOREACH(flag ${KRB5_C_CONFIG_LIBS}) + IF("${flag}" MATCHES "^-L") + STRING(REGEX REPLACE "^-L" "" DIR "${flag}") + FILE(TO_CMAKE_PATH "${DIR}" DIR) + SET(KRB5_LIBRARY_DIRS ${KRB5_LIBRARY_DIRS} "${DIR}") + ELSEIF("${flag}" MATCHES "^-l") + STRING(REGEX REPLACE "^-l" "" NAME "${flag}") + SET(KRB5_LIBRARY_NAMES ${KRB5_LIBRARY_NAMES} "${NAME}") + ENDIF("${flag}" MATCHES "^-L") + ENDFOREACH(flag) + + # add gssapi_krb5 (MIT) + #SET(KRB5_LIBRARY_NAMES ${KRB5_LIBRARY_NAMES} "gssapi_krb5") + # Add krb5support + SET(KRB5_LIBRARY_NAMES ${KRB5_LIBRARY_NAMES} "krb5support") + STRING(CONCAT KRB5_LINKFLAGS ${KRB5_LINKFLAGS} " -lkrb5support") + + # Search for each library needed using the directories given. + FOREACH(name ${KRB5_LIBRARY_NAMES}) + # Look for this library. + FIND_LIBRARY(KRB5_${name}_LIBRARY + NAMES ${name} + PATHS ${KRB5_LIBRARY_DIRS} + NO_DEFAULT_PATH + ) + FIND_LIBRARY(KRB5_${name}_LIBRARY NAMES ${name}) + MARK_AS_ADVANCED(KRB5_${name}_LIBRARY) + + # If any library is not found then the whole package is not found. + IF(NOT KRB5_${name}_LIBRARY) + SET(KRB5_FOUND 0) + ENDIF(NOT KRB5_${name}_LIBRARY) + + # Build an ordered list of all the libraries needed. + SET(KRB5_LIBRARIES ${KRB5_LIBRARIES} "${KRB5_${name}_LIBRARY}") + ENDFOREACH(name) + ELSE("${KRB5_C_CONFIG_RESULT}" MATCHES "^0$") + MESSAGE("Error running ${KRB5_C_CONFIG}: [${KRB5_C_CONFIG_RESULT}]") + SET(KRB5_FOUND 0) + ENDIF("${KRB5_C_CONFIG_RESULT}" MATCHES "^0$") +ENDIF(KRB5_FOUND) + +# Report the results. +IF(NOT KRB5_FOUND) + SET(KRB5_DIR_MESSAGE + "KRB5 was not found. Make sure the entries KRB5_* are set.") + IF(NOT KRB5_FIND_QUIETLY) + MESSAGE(STATUS "${KRB5_DIR_MESSAGE}") + ELSE(NOT KRB5_FIND_QUIETLY) + IF(KRB5_FIND_REQUIRED) + MESSAGE(FATAL_ERROR "${KRB5_DIR_MESSAGE}") + ENDIF(KRB5_FIND_REQUIRED) + ENDIF(NOT KRB5_FIND_QUIETLY) +ELSE(NOT KRB5_FOUND) + MESSAGE(STATUS "Found kerberos 5 headers: ${KRB5_INCLUDE_DIRS}") + MESSAGE(STATUS "Found kerberos 5 libs: ${KRB5_LIBRARIES}") +ENDIF(NOT KRB5_FOUND) diff --git a/cmake/FindLibevent.cmake b/cmake/FindLibevent.cmake new file mode 100644 index 00000000..4d314af9 --- /dev/null +++ b/cmake/FindLibevent.cmake @@ -0,0 +1,30 @@ +# - Try to find Libevent includes dirs and libraries +# +# Usage of this module as follows: +# +# find_package(Libevent) +# +# Variables used by this module, they can change the default behaviour and need +# to be set before calling find_package: +# +# Variables defined by this module: +# +# Libevent_FOUND System has Libevent, include and lib dirs found +# Libevent_INCLUDE_DIR The Libevent includes directories. +# Libevent_LIBRARY The Libevent library. + +find_path(Libevent_INCLUDE_DIR NAMES event.h) +find_library(Libevent_LIBRARY NAMES libevent.a) + +if(Libevent_INCLUDE_DIR AND Libevent_LIBRARY) + set(Libevent_FOUND TRUE) + mark_as_advanced( + Libevent_INCLUDE_DIR + Libevent_LIBRARY + ) +endif() + +if(NOT Libevent_FOUND) + message(FATAL_ERROR "Libevent doesn't exist") +endif() + diff --git a/cmake/FindLibunwind.cmake b/cmake/FindLibunwind.cmake new file mode 100644 index 00000000..3be74fa8 --- /dev/null +++ b/cmake/FindLibunwind.cmake @@ -0,0 +1,24 @@ +# FindLibunwind +# ------------- +# +# Find Libunwind +# +# Find LibUnwind library +# +# :: +# +# LIBUNWIND_LIBRARY_DIR - Can be provided to advise the search +# +# Libunwind_FOUND - True if libunwind is found. +# LIBUNWIND_LIBRARIES - libunwind libraries to link against. + +find_library(LIBUNWIND_LIBRARY NAMES unwind libunwind.so.8 PATHS ${LIBUNWIND_LIBRARY_DIR}) + +include(FindPackageHandleStandardArgs) +FIND_PACKAGE_HANDLE_STANDARD_ARGS(Libunwind REQUIRED_VARS LIBUNWIND_LIBRARY) + +if (Libunwind_FOUND) + set(LIBUNWIND_LIBRARIES ${LIBUNWIND_LIBRARY}) +endif () + +mark_as_advanced( LIBUNWIND_LIBRARY ) diff --git a/cmake/FindMstch.cmake b/cmake/FindMstch.cmake new file mode 100644 index 00000000..54636d47 --- /dev/null +++ b/cmake/FindMstch.cmake @@ -0,0 +1,32 @@ +# - Try to find Mstch includes dirs and libraries +# +# Usage of this module as follows: +# +# find_package(Mstch) +# +# Variables used by this module, they can change the default behaviour and need +# to be set before calling find_package: +# +# Variables defined by this module: +# +# Mstch_FOUND System has Mstch, include and lib dirs found +# Mstch_INCLUDE_DIR The Mstch includes directories. +# Mstch_LIBRARY The Mstch library. + +find_path(Mstch_INCLUDE_DIR NAMES mstch) +find_library(Mstch_LIBRARY NAMES libmstch.a) + +if(Mstch_INCLUDE_DIR AND Mstch_LIBRARY) + set(Mstch_FOUND TRUE) + mark_as_advanced( + Mstch_INCLUDE_DIR + Mstch_LIBRARY + ) + message(STATUS "Mstch_INCLUDE_DIR : ${Mstch_INCLUDE_DIR}") + message(STATUS "Mstch_LIBRARY : ${Mstch_LIBRARY}") +endif() + +if(NOT Mstch_FOUND) + message(FATAL_ERROR "Mstch doesn't exist") +endif() + diff --git a/cmake/FindNCURSES.cmake b/cmake/FindNCURSES.cmake new file mode 100644 index 00000000..eb4a0b6f --- /dev/null +++ b/cmake/FindNCURSES.cmake @@ -0,0 +1,49 @@ +# - Try to find ncurses include dirs and libraries +# +# Usage of this module as follows: +# +# find_package(NCURSES) +# +# Variables used by this module, they can change the default behaviour and need +# to be set before calling find_package: +# +# NCURSES_ROOT_DIR Set this variable to the root installation of +# ncurses if the module has problems finding the +# proper installation path. +# +# Variables defined by this module: +# +# NCURSES_FOUND ncurses is found, include and lib dir +# NCURSES_INCLUDE_DIR The ncurses include directory +# NCURSES_LIBRARY The ncurses library + +find_path( + NCURSES_ROOT_DIR + NAMES include/ncurses/curses.h +) + +find_path( + NCURSES_INCLUDE_DIR + NAMES ncurses.h curses.h ncurses/curses.h + HINTS ${NCURSES_ROOT_DIR}/include +) + +find_library( + NCURSES_LIBRARY + NAMES ncurses + HINTS ${NCURSES_ROOT_DIR}/lib +) + +if(NCURSES_INCLUDE_DIR AND NCURSES_LIBRARY_DIR) + set(NCURSES_FOUND TRUE) +else() + FIND_LIBRARY(NCURSES_LIBRARY NAMES ncurses) + include(FindPackageHandleStandardArgs) + FIND_PACKAGE_HANDLE_STANDARD_ARGS(ncurses DEFAULT_MSG NCURSES_INCLUDE_DIR NCURSES_LIBRARY) +endif() + +mark_as_advanced( + NCURSES_ROOT_DIR + NCURSES_INCLUDE_DIR + NCURSES_LIBRARY +) diff --git a/cmake/FindPCHSupport.cmake b/cmake/FindPCHSupport.cmake new file mode 100644 index 00000000..04a36b1d --- /dev/null +++ b/cmake/FindPCHSupport.cmake @@ -0,0 +1,95 @@ +# This code is based on +# http://rosegarden.svn.sourceforge.net/viewvc/rosegarden/trunk/rosegarden/cmake_admin/FindPCHSupport.cmake?revision=7699&view=markup +# +# - Try to find precompiled headers support for GCC 3.4 and 4.x +# Once done this will define: +# +# Variable: +# PCHSupport_FOUND +# +# Macro: +# ADD_PRECOMPILED_HEADER + +IF(${CMAKE_CXX_COMPILER_ID} STREQUAL "GNU") + EXEC_PROGRAM( + ${CMAKE_CXX_COMPILER} + ARGS --version + OUTPUT_VARIABLE _compiler_output) + STRING(REGEX REPLACE ".* ([0-9]\\.[0-9]\\.[0-9]) .*" "\\1" + gcc_compiler_version ${_compiler_output}) + IF(gcc_compiler_version MATCHES "[4-9]\\.[0-9]\\.[0-9]") + SET(PCHSupport_FOUND TRUE) + MESSAGE("-- Found PCH Support: gcc compiler version is " ${gcc_compiler_version}) + ELSE() + IF(gcc_compiler_version MATCHES "3\\.4\\.[0-9]") + SET(PCHSupport_FOUND TRUE) + MESSAGE("-- Found PCH Support: gcc compiler version is " ${gcc_compiler_version}) + ENDIF() + ENDIF() +ELSEIF(${CMAKE_CXX_COMPILER_ID} STREQUAL "Clang") + SET(PCHSupport_FOUND TRUE) +ENDIF() + + + +MACRO(ADD_PRECOMPILED_HEADER _targetName _input) + + GET_FILENAME_COMPONENT(_name ${_input} NAME) + SET(_source "${CMAKE_CURRENT_SOURCE_DIR}/${_input}") + SET(_output "${CMAKE_CURRENT_SOURCE_DIR}/${_name}.gch") + STRING(TOUPPER "CMAKE_CXX_FLAGS_${CMAKE_BUILD_TYPE}" _flags_var_name) + SET(_compiler_FLAGS ${${_flags_var_name}}) + GET_DIRECTORY_PROPERTY(_directory_compile_options COMPILE_OPTIONS) + LIST(APPEND _compiler_FLAGS ${_directory_compile_options}) + + GET_DIRECTORY_PROPERTY(_directory_flags INCLUDE_DIRECTORIES) + SET(_system_INCLUDE_DIRS "/usr/include" "/usr/local/include") + FOREACH(item ${_directory_flags}) + # Exclude standard paths + LIST(FIND _system_INCLUDE_DIRS ${item} _index) + IF(NOT ${_index} EQUAL -1) + continue() + ENDIF() + + IF(item MATCHES "^${PROJECT_SOURCE_DIR}.*") + # Directories in this project + IF(item MATCHES "^${PROJECT_SOURCE_DIR}/.*third-party.*") + # third-party + LIST(APPEND _compiler_FLAGS "-isystem ${item}") + ELSE() + # Our own directories + LIST(APPEND _compiler_FLAGS "-I ${item}") + ENDIF() + ELSE() + # All of others + LIST(APPEND _compiler_FLAGS "-isystem ${item}") + ENDIF() + ENDFOREACH(item) + + GET_DIRECTORY_PROPERTY(_directory_flags COMPILE_DEFINITIONS) + FOREACH(item ${_directory_flags}) + IF(NOT ${item} MATCHES "^GIT_INFO_SHA") + LIST(APPEND _compiler_FLAGS "-D${item}") + ENDIF() + ENDFOREACH(item) + + SEPARATE_ARGUMENTS(_compiler_FLAGS) + MESSAGE("Precompile header file " ${_source} " into " ${_output}) + IF(CMAKE_CXX_EXTENSIONS OR NOT DEFINED CMAKE_CXX_EXTENSIONS) + SET(_cxx_standard "gnu++${CMAKE_CXX_STANDARD}") + ELSE() + SET(_cxx_standard "c++${CMAKE_CXX_STANDARD}") + ENDIF() + ADD_CUSTOM_COMMAND( + OUTPUT ${_output} + COMMAND ${CMAKE_CXX_COMPILER} + ${_compiler_FLAGS} + -x c++-header + -std=${_cxx_standard} + -o ${_output} ${_source} + MAIN_DEPENDENCY ${_source} + DEPENDS ${CMAKE_BINARY_DIR}/CMakeCache.txt) + ADD_CUSTOM_TARGET(${_targetName}_gch DEPENDS ${_output}) + ADD_DEPENDENCIES(${_targetName} ${_targetName}_gch) + +ENDMACRO(ADD_PRECOMPILED_HEADER) diff --git a/cmake/FindProxygen.cmake b/cmake/FindProxygen.cmake new file mode 100644 index 00000000..88e888bb --- /dev/null +++ b/cmake/FindProxygen.cmake @@ -0,0 +1,31 @@ +# - Try to find Proxygen includes dirs and libraries +# +# Usage of this module as follows: +# +# find_package(Proxygen) +# +# Variables used by this module, they can change the default behaviour and need +# to be set before calling find_package: +# +# Variables defined by this module: +# +# Proxygen_FOUND System has Proxygen, include and lib dirs found +# Proxygen_INCLUDE_DIR The Proxygen includes directories. +# Proxygen_LIBRARY The Proxygen library. + +find_path(Proxygen_INCLUDE_DIR NAMES proxygen) +find_library(Proxygen_LIBRARY NAMES libproxygen.a) + +if(Proxygen_INCLUDE_DIR AND Proxygen_LIBRARY) + set(Proxygen_FOUND TRUE) + mark_as_advanced( + Proxygen_INCLUDE_DIR + Proxygen_LIBRARY + ) +endif(Proxygen_INCLUDE_DIR AND Proxygen_LIBRARY) + +if(NOT Proxygen_FOUND) + message(FATAL_ERROR "Proxygen doesn't exist") +endif() + + diff --git a/cmake/FindReadline.cmake b/cmake/FindReadline.cmake new file mode 100644 index 00000000..1458822a --- /dev/null +++ b/cmake/FindReadline.cmake @@ -0,0 +1,47 @@ +# - Try to find readline includes dirs and libraries +# +# Usage of this module as follows: +# +# find_package(Readline) +# +# Variables used by this module, they can change the default behaviour and need +# to be set before calling find_package: +# +# Readline_ROOT_DIR Set this variable to the root installation of +# readline if the module has problems finding the +# proper installation path. +# +# Variables defined by this module: +# +# READLINE_FOUND System has readline, include and lib dirs found +# Readline_INCLUDE_DIR The readline includes directories. +# Readline_LIBRARY The readline library. + +find_path(Readline_ROOT_DIR + NAMES include/readline/readline.h +) + +find_path(Readline_INCLUDE_DIR + NAMES readline/readline.h + HINTS ${Readline_ROOT_DIR}/include +) + +find_library(Readline_LIBRARY + NAMES readline + HINTS ${Readline_ROOT_DIR}/lib +) + +if(Readline_INCLUDE_DIR AND Readline_LIBRARY) + set(READLINE_FOUND TRUE) +else(Readline_INCLUDE_DIR AND Readline_LIBRARY) + FIND_LIBRARY(Readline_LIBRARY NAMES readline) + include(FindPackageHandleStandardArgs) + FIND_PACKAGE_HANDLE_STANDARD_ARGS(Readline DEFAULT_MSG Readline_INCLUDE_DIR Readline_LIBRARY ) + MARK_AS_ADVANCED(Readline_INCLUDE_DIR Readline_LIBRARY) +endif(Readline_INCLUDE_DIR AND Readline_LIBRARY) + +mark_as_advanced( + Readline_ROOT_DIR + Readline_INCLUDE_DIR + Readline_LIBRARY +) diff --git a/cmake/FindRocksdb.cmake b/cmake/FindRocksdb.cmake new file mode 100644 index 00000000..7160e18b --- /dev/null +++ b/cmake/FindRocksdb.cmake @@ -0,0 +1,30 @@ +# - Try to find Rocksdb includes dirs and libraries +# +# Usage of this module as follows: +# +# find_package(Rocksdb) +# +# Variables used by this module, they can change the default behaviour and need +# to be set before calling find_package: +# +# Variables defined by this module: +# +# Rocksdb_FOUND System has Rocksdb, include and lib dirs found +# Rocksdb_INCLUDE_DIR The Rocksdb includes directories. +# Rocksdb_LIBRARY The Rocksdb library. + +find_path(Rocksdb_INCLUDE_DIR NAMES rocksdb) +find_library(Rocksdb_LIBRARY NAMES librocksdb.a) + +if(Rocksdb_INCLUDE_DIR AND Rocksdb_LIBRARY) + set(Rocksdb_FOUND TRUE) + mark_as_advanced( + Rocksdb_INCLUDE_DIR + Rocksdb_LIBRARY + ) +endif() + +if(NOT Rocksdb_FOUND) + message(FATAL_ERROR "Rocksdb doesn't exist") +endif() + diff --git a/cmake/FindSnappy.cmake b/cmake/FindSnappy.cmake new file mode 100644 index 00000000..bb7b5d19 --- /dev/null +++ b/cmake/FindSnappy.cmake @@ -0,0 +1,30 @@ +# - Try to find Snappy includes dirs and libraries +# +# Usage of this module as follows: +# +# find_package(Snappy) +# +# Variables used by this module, they can change the default behaviour and need +# to be set before calling find_package: +# +# Variables defined by this module: +# +# Snappy_FOUND System has Snappy, include and lib dirs found +# Snappy_INCLUDE_DIR The Snappy includes directories. +# Snappy_LIBRARY The Snappy library. + +find_path(Snappy_INCLUDE_DIR NAMES snappy.h) +find_library(Snappy_LIBRARY NAMES libsnappy.a) + +if(Snappy_INCLUDE_DIR AND Snappy_LIBRARY) + set(Snappy_FOUND TRUE) + mark_as_advanced( + Snappy_INCLUDE_DIR + Snappy_LIBRARY + ) +endif() + +if(NOT Snappy_FOUND) + message(FATAL_ERROR "Snappy doesn't exist") +endif() + diff --git a/cmake/FindSodium.cmake b/cmake/FindSodium.cmake new file mode 100644 index 00000000..01143cdd --- /dev/null +++ b/cmake/FindSodium.cmake @@ -0,0 +1,30 @@ +# - Try to find Sodium includes dirs and libraries +# +# Usage of this module as follows: +# +# find_package(Sodium) +# +# Variables used by this module, they can change the default behaviour and need +# to be set before calling find_package: +# +# Variables defined by this module: +# +# Sodium_FOUND System has Sodium, include and lib dirs found +# Sodium_INCLUDE_DIR The Sodium includes directories. +# Sodium_LIBRARY The Sodium library. + +find_path(Sodium_INCLUDE_DIR NAMES sodium) +find_library(Sodium_LIBRARY NAMES libsodium.a) + +if(Sodium_INCLUDE_DIR AND Sodium_LIBRARY) + set(Sodium_FOUND TRUE) + mark_as_advanced( + Sodium_INCLUDE_DIR + Sodium_LIBRARY + ) +endif() + +if(NOT Sodium_FOUND) + message(FATAL_ERROR "Sodium doesn't exist") +endif() + diff --git a/cmake/FindWangle.cmake b/cmake/FindWangle.cmake new file mode 100644 index 00000000..d3e55e04 --- /dev/null +++ b/cmake/FindWangle.cmake @@ -0,0 +1,30 @@ +# - Try to find Wangle includes dirs and libraries +# +# Usage of this module as follows: +# +# find_package(Wangle) +# +# Variables used by this module, they can change the default behaviour and need +# to be set before calling find_package: +# +# Variables defined by this module: +# +# Wangle_FOUND System has Wangle, include and lib dirs found +# Wangle_INCLUDE_DIR The Wangle includes directories. +# Wangle_LIBRARY The Wangle library. + +find_path(Wangle_INCLUDE_DIR NAMES wangle) +find_library(Wangle_LIBRARY NAMES libwangle.a) + +if(Wangle_INCLUDE_DIR AND Wangle_LIBRARY) + set(Wangle_FOUND TRUE) + mark_as_advanced( + Wangle_INCLUDE_DIR + Wangle_LIBRARY + ) +endif() + +if(NOT Wangle_FOUND) + message(FATAL_ERROR "Wangle doesn't exist") +endif() + diff --git a/cmake/FindZstd.cmake b/cmake/FindZstd.cmake new file mode 100644 index 00000000..3501b1c7 --- /dev/null +++ b/cmake/FindZstd.cmake @@ -0,0 +1,32 @@ +# - Try to find Zstd includes dirs and libraries +# +# Usage of this module as follows: +# +# find_package(Zstd) +# +# Variables used by this module, they can change the default behaviour and need +# to be set before calling find_package: +# +# Variables defined by this module: +# +# Zstd_FOUND System has Zstd, include and lib dirs found +# Zstd_INCLUDE_DIR The Zstd includes directories. +# Zstd_LIBRARY The Zstd library. +# Zstd_BIN The Zstd binary. + +find_path(Zstd_INCLUDE_DIR NAMES zstd.h) +find_library(Zstd_LIBRARY NAMES libzstd.a) + +if(Zstd_INCLUDE_DIR AND Zstd_LIBRARY) + set(Zstd_FOUND TRUE) + mark_as_advanced( + Zstd_INCLUDE_DIR + Zstd_LIBRARY + ) +endif() + +if(NOT Zstd_FOUND) + message(FATAL_ERROR "Zstd doesn't exist") +endif() + + diff --git a/cmake/ThriftGenerate.cmake b/cmake/ThriftGenerate.cmake new file mode 100644 index 00000000..8453a9fc --- /dev/null +++ b/cmake/ThriftGenerate.cmake @@ -0,0 +1,138 @@ +# +# Requirements: +# Please provide the following two variables before using these macros: +# ${THRIFT1} - path/to/bin/thrift1 +# ${THRIFT_TEMPLATES} - path/to/include/thrift/templates +# ${THRIFTCPP2} - path/to/lib/thriftcpp2 +# +# +# bypass_source_check +# This tells cmake to ignore if it doesn't see the following sources in +# the library that will be installed. Thrift files are generated at compile +# time so they do not exist at source check time +# +# Params: +# @sources - The list of files to ignore in source check +# + +macro(bypass_source_check sources) +set_source_files_properties( + ${sources} + PROPERTIES GENERATED TRUE + ) +endmacro() + + +# +# thrift_generate +# This is used to codegen thrift files using the thrift compiler +# Params: +# @file_name - The name of tge thrift file +# @services - A list of services that are declared in the thrift file +# @output_path - The directory where the thrift file lives +# +# Output: +# file-cpp2-target - A custom target to add a dependenct +# ${file-cpp2-HEADERS} - The generated Header Files. +# ${file-cpp2-SOURCES} - The generated Source Files. +# +# Notes: +# If any of the fields is empty, it is still required to provide an empty string +# +# When using file_cpp2-SOURCES it should always call: +# bypass_source_check(${file_cpp2-SOURCES}) +# This will prevent cmake from complaining about missing source files +# + +macro(thrift_generate file_name services file_path output_path include_prefix) +set("${file_name}-cpp2-HEADERS" + ${output_path}/gen-cpp2/${file_name}_constants.h + ${output_path}/gen-cpp2/${file_name}_data.h + ${output_path}/gen-cpp2/${file_name}_types.h + ${output_path}/gen-cpp2/${file_name}_types_custom_protocol.h + ${output_path}/gen-cpp2/${file_name}_types.tcc +) + +set("${file_name}-cpp2-SOURCES" + ${output_path}/gen-cpp2/${file_name}_constants.cpp + ${output_path}/gen-cpp2/${file_name}_data.cpp + ${output_path}/gen-cpp2/${file_name}_metadata.cpp + ${output_path}/gen-cpp2/${file_name}_types.cpp +) + +foreach(service ${services}) + set("${file_name}-cpp2-HEADERS" + ${${file_name}-cpp2-HEADERS} + ${output_path}/gen-cpp2/${service}.h + ${output_path}/gen-cpp2/${service}.tcc + ${output_path}/gen-cpp2/${service}AsyncClient.h + ${output_path}/gen-cpp2/${service}_custom_protocol.h + ) + set("${file_name}-cpp2-SOURCES" + ${${file_name}-cpp2-SOURCES} + ${output_path}/gen-cpp2/${service}.cpp + ${output_path}/gen-cpp2/${service}AsyncClient.cpp + ${output_path}/gen-cpp2/${service}_processmap_binary.cpp + ${output_path}/gen-cpp2/${service}_processmap_compact.cpp + ) +endforeach() + +add_custom_command( + OUTPUT ${${file_name}-cpp2-HEADERS} ${${file_name}-cpp2-SOURCES} + COMMAND ${THRIFT1} + --strict "--allow-neg-enum-vals" + --gen "mstch_cpp2:include_prefix=${include_prefix},stack_arguments" + --gen "py" + --gen "js:node:" + --gen "csharp" + --gen "java:hashcode" + --gen "go:thrift_import=github.com/facebook/fbthrift/thrift/lib/go/thrift,package_prefix=github.com/vesoft-inc/nebula-go/v2/,use_context" + -o "." "${file_path}/${file_name}.thrift" + COMMAND + mkdir -p "./gen-rust/${file_name}" + && ${THRIFT1} + --strict "--allow-neg-enum-vals" + --gen "mstch_rust" + -o "gen-rust/${file_name}" + "${file_path}/${file_name}.thrift" + && ( mv ./gen-rust/${file_name}/gen-rust/lib.rs ./gen-rust/${file_name} ) + && ( rm -r ./gen-rust/${file_name}/gen-rust/ ) + DEPENDS "${file_path}/${file_name}.thrift" + COMMENT "Generating thrift files for ${file_name}" +) + +bypass_source_check(${${file_name}-cpp2-SOURCES}) +add_custom_target( + ${file_name}_thrift_generator + DEPENDS ${${file_name}-cpp2-HEADERS} ${${file_name}-cpp2-SOURCES} +) + +add_library( + "${file_name}_thrift_obj" + OBJECT + ${${file_name}-cpp2-SOURCES} +) +add_dependencies(${file_name}_thrift_obj ${file_name}_thrift_generator) + +set_target_properties( + "${file_name}_thrift_obj" + PROPERTIES CXX_CLANG_TIDY "" +) + +target_compile_options(${file_name}_thrift_obj PRIVATE "-Wno-pedantic") +target_compile_options(${file_name}_thrift_obj PRIVATE "-Wno-extra") + +if(NOT "${file_name}" STREQUAL "common") + add_dependencies( + ${file_name}_thrift_obj + common_thrift_generator + ) +endif() + +if("${file_name}" STREQUAL "storage") + add_dependencies( + ${file_name}_thrift_obj + meta_thrift_generator + ) +endif() +endmacro() diff --git a/cmake/nebula/ABIConfig.cmake b/cmake/nebula/ABIConfig.cmake new file mode 100644 index 00000000..2ef15f0e --- /dev/null +++ b/cmake/nebula/ABIConfig.cmake @@ -0,0 +1,8 @@ +# Is abi 11 +if (${DISABLE_CXX11_ABI}) + message(STATUS "Set D_GLIBCXX_USE_CXX11_ABI to 0") + add_compile_options(-D_GLIBCXX_USE_CXX11_ABI=0) +else() + message(STATUS "Set D_GLIBCXX_USE_CXX11_ABI to 1") + add_compile_options(-D_GLIBCXX_USE_CXX11_ABI=1) +endif() diff --git a/cmake/nebula/CcacheConfig.cmake b/cmake/nebula/CcacheConfig.cmake new file mode 100644 index 00000000..ad0816bd --- /dev/null +++ b/cmake/nebula/CcacheConfig.cmake @@ -0,0 +1,16 @@ +# To detect if ccache is available +find_program(ccache_program_found "ccache") +if (ENABLE_CCACHE AND ccache_program_found) + if (NOT $ENV{CCACHE_DIR} STREQUAL "") + message(STATUS "CCACHE_DIR : $ENV{CCACHE_DIR}") + else() + message(STATUS "CCACHE_DIR : $ENV{HOME}/.ccache") + endif() + set(CMAKE_CXX_COMPILER_LAUNCHER "ccache") +elseif (ENABLE_CCACHE) + message(STATUS "CCACHE : Enabled but not found") + set(CMAKE_CXX_COMPILER_LAUNCHER) +else () + message(STATUS "CCACHE : OFF") + set(CMAKE_CXX_COMPILER_LAUNCHER) +endif() diff --git a/cmake/nebula/GeneralCMakeConfig.cmake b/cmake/nebula/GeneralCMakeConfig.cmake new file mode 100644 index 00000000..8c71828f --- /dev/null +++ b/cmake/nebula/GeneralCMakeConfig.cmake @@ -0,0 +1,25 @@ +# By default, all dynamic and static libraries will be placed at ${CMAKE_BINARY_DIR}/lib, +# while all executables at ${CMAKE_BINARY_DIR}/bin. +# But for the sake of cleanliness, all executables ending with `_test' will be placed +# at ${CMAKE_BINARY_DIR}/bin/test, while those ending with `_bm' at ${CMAKE_BINARY_DIR}/bin/bench. +# Please see `nebula_add_executable' for this rule. +set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/lib") +set(CMAKE_LIBRARY_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/lib") +set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin") + +if(ENABLE_TESTING) + enable_testing() +endif() + +if(NOT CMAKE_BUILD_TYPE) + set(CMAKE_BUILD_TYPE Debug) +endif() +print_config(CMAKE_BUILD_TYPE) + +if (${CMAKE_INSTALL_PREFIX} STREQUAL "/usr/local") + set(CMAKE_INSTALL_PREFIX "/usr/local/nebula") +endif() +print_config(CMAKE_INSTALL_PREFIX) + + +set(CMAKE_SKIP_RPATH TRUE) diff --git a/cmake/nebula/GeneralCMakeOptions.cmake b/cmake/nebula/GeneralCMakeOptions.cmake new file mode 100644 index 00000000..8fc3fd7a --- /dev/null +++ b/cmake/nebula/GeneralCMakeOptions.cmake @@ -0,0 +1,28 @@ +############ Nebula defined options immutable during configure stage ############# +message(">>>> Options of ${PROJECT_NAME} <<<<") +option(ENABLE_TESTING "Build unit tests" ON) +option(ENABLE_CCACHE "Use ccache to speed up compiling" ON) +option(ENABLE_WERROR "Regard warnings as errors" ON) +option(ENABLE_JEMALLOC "Use jemalloc as memory allocator" ON) +option(ENABLE_ASAN "Build with AddressSanitizer" OFF) +option(ENABLE_UBSAN "Build with UndefinedBehaviourSanitizer" OFF) +option(ENABLE_TSAN "Build with ThreadSanitizer" OFF) +option(ENABLE_STATIC_ASAN "Statically link against libasan" OFF) +option(ENABLE_STATIC_UBSAN "Statically link against libubsan" OFF) +option(ENABLE_FUZZY_TESTING "Enable Fuzzy tests" OFF) +option(ENABLE_FRAME_POINTER "Build with frame pointer" OFF) +option(ENABLE_STRICT_ALIASING "Build with -fstrict-aliasing" OFF) +option(ENABLE_COVERAGE "Build with coverage report" OFF) +option(ENABLE_PIC "Build with -fPIC" OFF) +option(ENABLE_COMPRESSED_DEBUG_INFO "Compress debug info to reduce binary size" ON) +option(ENABLE_CLANG_TIDY "Enable clang-tidy if present" OFF) +option(ENABLE_GDB_SCRIPT_SECTION "Add .debug_gdb_scripts section" OFF) +option(DISABLE_CXX11_ABI "Whether to disable cxx11 abi" OFF) + +get_cmake_property(variable_list VARIABLES) +foreach(_varname ${variable_list}) + string(REGEX MATCH "^ENABLE" matched ${_varname}) + if(matched) + print_option(${_varname}) + endif() +endforeach() diff --git a/cmake/nebula/GeneralCompilerConfig.cmake b/cmake/nebula/GeneralCompilerConfig.cmake new file mode 100644 index 00000000..a914a49a --- /dev/null +++ b/cmake/nebula/GeneralCompilerConfig.cmake @@ -0,0 +1,92 @@ +set(CMAKE_CXX_STANDARD 17) +set(CMAKE_CXX_STANDARD_REQUIRED ON) +set(CMAKE_CXX_EXTENSIONS OFF) + +print_config(CMAKE_CXX_STANDARD) +print_config(CMAKE_CXX_COMPILER) +print_config(CMAKE_CXX_COMPILER_ID) + +if (!CMAKE_CXX_COMPILER) + message(FATAL_ERROR "No C++ compiler found") +endif() + +include(CheckCXXCompilerFlag) + +add_compile_options(-Wall) +add_compile_options(-Wextra) +add_compile_options(-Wpedantic) +add_compile_options(-Wunused-parameter) +add_compile_options(-Wshadow) +add_compile_options(-Wnon-virtual-dtor) +add_compile_options(-Woverloaded-virtual) +add_compile_options(-Wignored-qualifiers) + +# For s2 +add_definitions(-DS2_USE_GLOG) +add_definitions(-DS2_USE_GFLAGS) +# For breakpad +add_definitions(-D__STDC_FORMAT_MACROS) + +include_directories(AFTER ${CMAKE_SOURCE_DIR}/src) +include_directories(AFTER ${CMAKE_CURRENT_BINARY_DIR}/src) + + +if(ENABLE_WERROR) + add_compile_options(-Werror) +endif() + +if(NOT ENABLE_STRICT_ALIASING) + add_compile_options(-fno-strict-aliasing) +else() + add_compile_options(-fstrict-aliasing) +endif() + +if(ENABLE_FRAME_POINTER) + add_compile_options(-fno-omit-frame-pointer) +else() + add_compile_options(-fomit-frame-pointer) +endif() + +if(ENABLE_PIC) + add_compile_options(-fPIC) +endif() + +if(ENABLE_TESTING AND ENABLE_COVERAGE) + add_compile_options(--coverage) + add_compile_options(-g) + add_compile_options(-O0) + nebula_add_exe_linker_flag(-coverage) + nebula_add_exe_linker_flag(-lgcov) +endif() + +# TODO(doodle) Add option suggest-override for gnu +if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang") + # Here we need to specify the path of libstdc++ used by Clang + if(NOT ${NEBULA_CLANG_USE_GCC_TOOLCHAIN} STREQUAL "") + print_config(NEBULA_CLANG_USE_GCC_TOOLCHAIN) + execute_process( + COMMAND ${NEBULA_CLANG_USE_GCC_TOOLCHAIN}/bin/gcc -dumpmachine + OUTPUT_VARIABLE gcc_target_triplet + OUTPUT_STRIP_TRAILING_WHITESPACE + ) + add_compile_options("--gcc-toolchain=${NEBULA_CLANG_USE_GCC_TOOLCHAIN}") + nebula_add_exe_linker_flag(--gcc-toolchain=${NEBULA_CLANG_USE_GCC_TOOLCHAIN}) + nebula_add_shared_linker_flag(--gcc-toolchain=${NEBULA_CLANG_USE_GCC_TOOLCHAIN}) + if(NOT "${gcc_target_triplet}" STREQUAL "") + add_compile_options(--target=${gcc_target_triplet}) + nebula_add_exe_linker_flag(--target=${gcc_target_triplet}) + nebula_add_shared_linker_flag(--target=${gcc_target_triplet}) + endif() + endif() +#add_compile_options(-Wno-mismatched-tags) + add_compile_options(-Wno-self-assign-overloaded) + add_compile_options(-Wno-self-move) + add_compile_options(-Wno-format-pedantic) + add_compile_options(-Wno-gnu-zero-variadic-macro-arguments) + set(libatomic_link_flags "-Wl,-Bstatic -latomic -Wl,-Bdynamic") + set(CMAKE_REQUIRED_FLAGS "${libatomic_link_flags}") + check_cxx_compiler_flag("${libatomic_link_flags}" has_static_libatomic) + if(NOT has_static_libatomic) + set(libatomic_link_flags "-latomic") + endif() +endif() diff --git a/cmake/nebula/GitHooksConfig.cmake b/cmake/nebula/GitHooksConfig.cmake new file mode 100644 index 00000000..526bb984 --- /dev/null +++ b/cmake/nebula/GitHooksConfig.cmake @@ -0,0 +1,19 @@ +if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/.git/") + # Create the pre-commit hook every time we run cmake + message(STATUS "Create the pre-commit hook") + set(PRE_COMMIT_HOOK ${CMAKE_CURRENT_SOURCE_DIR}/.git/hooks/pre-commit) + execute_process( + COMMAND + "rm" "-f" ${PRE_COMMIT_HOOK} + ) + execute_process( + COMMAND + "ln" "-s" ${CMAKE_CURRENT_SOURCE_DIR}/.linters/cpp/hooks/pre-commit.sh ${PRE_COMMIT_HOOK} + RESULT_VARIABLE retcode + ) + if(${retcode} EQUAL 0) + MESSAGE(STATUS "Creating pre-commit hook done") + else() + MESSAGE(FATAL_ERROR "Creating pre-commit hook failed: ${retcode}") + endif() +endif() diff --git a/cmake/nebula/GitInfoConfig.cmake b/cmake/nebula/GitInfoConfig.cmake new file mode 100644 index 00000000..c5e67035 --- /dev/null +++ b/cmake/nebula/GitInfoConfig.cmake @@ -0,0 +1,12 @@ +find_package(Git) +if (GIT_FOUND AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/.git") + execute_process( + COMMAND ${GIT_EXECUTABLE} rev-parse --short HEAD + WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} + OUTPUT_VARIABLE GIT_INFO_SHA + ) +endif() + +if (GIT_INFO_SHA) + string(REGEX REPLACE "[^0-9a-f]+" "" GIT_INFO_SHA "${GIT_INFO_SHA}") +endif() diff --git a/cmake/nebula/InstallThirdParty.cmake b/cmake/nebula/InstallThirdParty.cmake new file mode 100644 index 00000000..f0a5a389 --- /dev/null +++ b/cmake/nebula/InstallThirdParty.cmake @@ -0,0 +1,28 @@ +set(third_party_install_prefix ${CMAKE_BINARY_DIR}/third-party/install) +message(STATUS "Downloading prebuilt third party automatically...") +if(${CMAKE_CXX_COMPILER_ID} STREQUAL "Clang") + if(NOT ${NEBULA_CLANG_USED_GCC_TOOLCHAIN} STREQUAL "") + set(cxx_cmd ${NEBULA_CLANG_USED_GCC_TOOLCHAIN}/bin/g++) + else() + set(cxx_cmd ${CMAKE_CXX_COMPILER}) + endif() +else() + set(cxx_cmd ${CMAKE_CXX_COMPILER}) +endif() +if(${DISABLE_CXX11_ABI}) + set(cxx_cmd "${cxx_cmd} -D_GLIBCXX_USE_CXX11_ABI=0") +else() + set(cxx_cmd "${cxx_cmd} -D_GLIBCXX_USE_CXX11_ABI=1") +endif() +message(STATUS "cxx_cmd: ${cxx_cmd}") +execute_process( + COMMAND + env CXX=${cxx_cmd} version=${NEBULA_THIRDPARTY_VERSION} ${CMAKE_SOURCE_DIR}/third-party/install-third-party.sh --prefix=${third_party_install_prefix} + WORKING_DIRECTORY + ${CMAKE_BINARY_DIR} +) + +if(EXISTS ${third_party_install_prefix}) + set(NEBULA_THIRDPARTY_ROOT ${third_party_install_prefix}) +endif() +unset(third_party_install_prefix) diff --git a/cmake/nebula/LinkerConfig.cmake b/cmake/nebula/LinkerConfig.cmake new file mode 100644 index 00000000..469844fb --- /dev/null +++ b/cmake/nebula/LinkerConfig.cmake @@ -0,0 +1,57 @@ +execute_process( + COMMAND + ld --version + COMMAND + head -1 + COMMAND + cut -d " " -f2 + OUTPUT_VARIABLE default_linker_type + OUTPUT_STRIP_TRAILING_WHITESPACE +) + +if ("${default_linker_type}" STREQUAL "ld") + set(default_linker_type "bfd") +endif() + +if (NOT DEFINED NEBULA_USE_LINKER) + set(NEBULA_USE_LINKER ${default_linker_type}) +endif() +print_config(NEBULA_USE_LINKER) + +nebula_add_exe_linker_flag(-fuse-ld=${NEBULA_USE_LINKER}) +nebula_add_shared_linker_flag(-fuse-ld=${NEBULA_USE_LINKER}) +nebula_add_exe_linker_flag(-static-libstdc++) +nebula_add_exe_linker_flag(-static-libgcc) +nebula_add_exe_linker_flag(-no-pie) +nebula_add_exe_linker_flag(-rdynamic) + +if(NOT ${CMAKE_BUILD_TYPE} STREQUAL "Debug") + add_definitions(-D_FORTIFY_SOURCE=2) +else() + # The mips need to add it when build Debug to lift the usual restrictions on the size of the global offset table. + if (${CMAKE_HOST_SYSTEM_PROCESSOR} MATCHES "mips64") + add_compile_options(-mxgot) + endif() + + if (NOT ${NEBULA_USE_LINKER} STREQUAL "gold" AND NOT ENABLE_GDB_SCRIPT_SECTION) + # `gold' linker is buggy for `--gc-sections', disabled for it + # `gc-sections' will discard the `.debug_gdb_scripts' section if enabled + add_compile_options(-ffunction-sections) + add_compile_options(-fdata-sections) + nebula_add_exe_linker_flag(-Wl,--gc-sections) + endif() +endif() + +if(CMAKE_BUILD_TYPE STREQUAL "Debug" OR CMAKE_BUILD_TYPE STREQUAL "RelWithDebInfo") + # The mips not supported + if (NOT ${CMAKE_HOST_SYSTEM_PROCESSOR} MATCHES "mips64") + if(ENABLE_COMPRESSED_DEBUG_INFO) + nebula_add_exe_linker_flag(-Wl,--compress-debug-sections=zlib) + else() + nebula_remove_exe_linker_flag(-Wl,--compress-debug-sections=zlib) + endif() + endif() + if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang") + add_compile_options(-fno-limit-debug-info) + endif() +endif() diff --git a/cmake/nebula/MakeBisonRelocatable.cmake b/cmake/nebula/MakeBisonRelocatable.cmake new file mode 100644 index 00000000..683c9365 --- /dev/null +++ b/cmake/nebula/MakeBisonRelocatable.cmake @@ -0,0 +1,17 @@ +set(BISON_EXECUTE_ENV "") +execute_process( + COMMAND ${BISON_EXECUTABLE} --print-datadir + OUTPUT_VARIABLE bison_encoded_data_dir + OUTPUT_STRIP_TRAILING_WHITESPACE +) +if(NOT EXISTS ${bison_encoded_data_dir}) + get_filename_component(bison_prefix ${BISON_EXECUTABLE} DIRECTORY) + get_filename_component(bison_prefix ${bison_prefix} DIRECTORY) + if(EXISTS ${bison_prefix}/share/bison) + set(BISON_EXECUTE_ENV "BISON_PKGDATADIR=${bison_prefix}/share/bison") + endif() +endif() +if(NOT ${BISON_EXECUTE_ENV} STREQUAL "") + set(BISON_EXECUTABLE ${CMAKE_COMMAND} -E env ${BISON_EXECUTE_ENV} ${BISON_EXECUTABLE}) +endif() + diff --git a/cmake/nebula/NebulaCMakeMacros.cmake b/cmake/nebula/NebulaCMakeMacros.cmake new file mode 100644 index 00000000..f44e45d2 --- /dev/null +++ b/cmake/nebula/NebulaCMakeMacros.cmake @@ -0,0 +1,168 @@ +macro(nebula_add_executable) + cmake_parse_arguments( + nebula_exec # prefix + "" # + "NAME" # + "SOURCES;OBJECTS;LIBRARIES" # + ${ARGN} + ) + add_executable( + ${nebula_exec_NAME} + ${nebula_exec_SOURCES} + ${nebula_exec_OBJECTS} + ) + nebula_link_libraries( + ${nebula_exec_NAME} + ${nebula_exec_LIBRARIES} + ) + + if(${nebula_exec_NAME} MATCHES "_test$") + set_target_properties( + ${nebula_exec_NAME} + PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin/test + ) + elseif(${nebula_exec_NAME} MATCHES "_bm$") + set_target_properties( + ${nebula_exec_NAME} + PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin/bench + ) + endif() + if(TARGET common_project) + add_dependencies( + ${nebula_exec_NAME} + common_project + ) + endif() +endmacro() + +macro(nebula_add_test) + cmake_parse_arguments( + nebula_test # prefix + "DISABLED;FUZZER" # + "NAME" # + "SOURCES;OBJECTS;LIBRARIES" # + ${ARGN} + ) + + nebula_add_executable( + NAME ${nebula_test_NAME} + SOURCES ${nebula_test_SOURCES} + OBJECTS ${nebula_test_OBJECTS} + LIBRARIES ${nebula_test_LIBRARIES} + ) + + if (${nebula_test_FUZZER}) + #Currently only Clang supports fuzz test + if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang") + set_target_properties(${nebula_test_NAME} PROPERTIES COMPILE_FLAGS "-g -fsanitize=fuzzer") + set_target_properties(${nebula_test_NAME} PROPERTIES LINK_FLAGS "-fsanitize=fuzzer") + endif() + elseif (NOT ${nebula_test_DISABLED}) + string(REGEX REPLACE "${CMAKE_SOURCE_DIR}/src/(.*)/test" "\\1" test_group ${CMAKE_CURRENT_SOURCE_DIR}) + add_test(NAME ${nebula_test_NAME} COMMAND ${nebula_test_NAME}) + set_tests_properties(${nebula_test_NAME} PROPERTIES LABELS ${test_group}) + # e.g. cmake -DNEBULA_ASAN_PRELOAD=/path/to/libasan.so + # or, cmake -DNEBULA_ASAN_PRELOAD=`/path/to/gcc --print-file-name=libasan.so` + if (NEBULA_ASAN_PRELOAD) + set_property( + TEST ${nebula_test_NAME} + PROPERTY ENVIRONMENT LD_PRELOAD=${NEBULA_ASAN_PRELOAD} + ) + endif() + endif() +endmacro() + +# A wrapper for target_link_libraries() +macro(nebula_link_libraries target) + target_link_libraries( + ${target} + ${ARGN} + folly + fmt + glog + gflags + boost_context + boost_system + boost_regex + boost_filesystem + boost_program_options + event + double-conversion + s2 + ${OPENSSL_SSL_LIBRARY} + ${OPENSSL_CRYPTO_LIBRARY} + ${KRB5_LIBRARIES} + ${COMPRESSION_LIBRARIES} + ${JEMALLOC_LIB} + ${LIBUNWIND_LIBRARIES} + keyutils + resolv + dl + ${GETTIME_LIB} + ${libatomic_link_flags} + -pthread + z + ${COVERAGES} + ${Breakpad_LIBRARY} + ) +endmacro(nebula_link_libraries) + +function(nebula_add_subdirectory dir_name) + if ((NOT ENABLE_TESTING) AND (${dir_name} MATCHES test)) + add_subdirectory(${dir_name} EXCLUDE_FROM_ALL) + return() + endif() + add_subdirectory(${dir_name}) +endfunction() + +macro(nebula_add_exe_linker_flag flag) + string(FIND "${CMAKE_EXE_LINKER_FLAGS}" "${flag}" position) + if(${position} EQUAL -1) + set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${flag}") + endif() +endmacro() + +macro(nebula_remove_exe_linker_flag flag) + string(REPLACE "${flag}" "" output "${CMAKE_EXE_LINKER_FLAGS}") + set(CMAKE_EXE_LINKER_FLAGS "${output}") +endmacro() + +macro(nebula_add_shared_linker_flag flag) + string(FIND "${CMAKE_SHARED_LINKER_FLAGS}" "${flag}" position) + if(${position} EQUAL -1) + set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} ${flag}") + endif() +endmacro() + +macro(nebula_remove_shared_linker_flag flag) + string(REPLACE "${flag}" "" output "${CMAKE_SHARED_LINKER_FLAGS}") + set(CMAKE_SHARED_LINKER_FLAGS "${output}") +endmacro() + +function(nebula_string_rpad output width fill_char value) + string(LENGTH ${value} length) + math(EXPR delta "${width} - ${length}") + set(pads "") + if(${delta} GREATER 0) + math(EXPR delta "${delta} - 1") + foreach(loop_var RANGE ${delta}) + set(pads "${pads}${fill_char}") + endforeach() + endif() + set(${output} "${value}${pads}" PARENT_SCOPE) +endfunction() + +macro(print_option name) + get_property(helpstring CACHE ${name} PROPERTY HELPSTRING) + nebula_string_rpad(padded 32 " " "${name}") + string(FIND "${helpstring}" "No help" position) + if(helpstring AND ${position} EQUAL -1) + message(STATUS "${padded}: ${${name}} (${helpstring})") + else() + message(STATUS "${padded}: ${${name}}") + endif() +endmacro() + +macro(print_config name) + print_option(${name}) +endmacro() diff --git a/cmake/nebula/NebulaCustomTargets.cmake b/cmake/nebula/NebulaCustomTargets.cmake new file mode 100644 index 00000000..ee96190e --- /dev/null +++ b/cmake/nebula/NebulaCustomTargets.cmake @@ -0,0 +1,30 @@ +set(NEBULA_CLEAN_ALL_DEPS clean-interface clean-bin) + +add_custom_target( + clean-bin + COMMAND "rm" "-fr" "bin/*" +) + +add_custom_target( + clean-build + COMMAND ${CMAKE_MAKE_PROGRAM} clean + COMMAND "find" "." "-name" "Testing" "|" "xargs" "rm" "-fr" + DEPENDS ${NEBULA_CLEAN_ALL_DEPS} +) + +add_custom_target( + clean-all + COMMAND ${CMAKE_MAKE_PROGRAM} clean + COMMAND "find" "." "-name" "Testing" "|" "xargs" "rm" "-fr" + DEPENDS ${NEBULA_CLEAN_ALL_DEPS} +) + +add_custom_target( + distclean + COMMAND "find" "." "-name" "CMakeFiles" "|" "xargs" "rm" "-fr" + COMMAND "find" "." "-name" "CMakeCache.txt" "|" "xargs" "rm" "-f" + COMMAND "find" "." "-name" "cmake_install.cmake" "|" "xargs" "rm" "-f" + COMMAND "find" "." "-name" "CTestTestfile.cmake" "|" "xargs" "rm" "-f" + COMMAND "find" "." "-name" "Makefile" "|" "xargs" "rm" "-f" + DEPENDS clean-all +) diff --git a/cmake/nebula/PlatformCheck.cmake b/cmake/nebula/PlatformCheck.cmake new file mode 100644 index 00000000..bea9a565 --- /dev/null +++ b/cmake/nebula/PlatformCheck.cmake @@ -0,0 +1,3 @@ +if(${CMAKE_SYSTEM_NAME} MATCHES "(Darwin|FreeBSD|Windows)") + MESSAGE(FATAL_ERROR "Only Linux is supported") +endif () diff --git a/cmake/nebula/SanitizerConfig.cmake b/cmake/nebula/SanitizerConfig.cmake new file mode 100644 index 00000000..28b5d500 --- /dev/null +++ b/cmake/nebula/SanitizerConfig.cmake @@ -0,0 +1,62 @@ +if(ENABLE_ASAN OR ENABLE_UBSAN) + add_definitions(-DBUILT_WITH_SANITIZER) +endif() + +if(ENABLE_ASAN) + set(CMAKE_REQUIRED_FLAGS "-fsanitize=address") + check_cxx_compiler_flag("-fsanitize=address" ENABLE_ASAN_OK) + if (NOT ENABLE_ASAN_OK) + MESSAGE(FATAL_ERROR "The compiler does not support address sanitizer") + endif() + if(ENABLE_STATIC_ASAN AND "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU") + add_compile_options(-static-libasan) + set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -static-libasan") + endif() + add_compile_options(-fsanitize=address) + add_compile_options(-g) + add_compile_options(-fno-omit-frame-pointer) + set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fsanitize=address") +endif() + +if(ENABLE_TSAN) + if (ENABLE_ASAN) + MESSAGE(FATAL_ERROR "ENABLE_TSAN cannot be combined with ENABLE_ASAN") + endif() + set(CMAKE_REQUIRED_FLAGS "-fsanitize=thread") + check_cxx_compiler_flag("-fsanitize=thread" ENABLE_TSAN_OK) + if (NOT ENABLE_TSAN_OK) + MESSAGE(FATAL_ERROR "The compiler does not support thread sanitizer") + endif() + set(ENV{TSAN_OPTIONS} "report_atomic_races=0") + add_compile_options(-fsanitize=thread) + add_compile_options(-g) + add_compile_options(-fno-omit-frame-pointer) + set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fsanitize=thread") +endif() + +if(ENABLE_UBSAN) + check_cxx_compiler_flag("-fsanitize=undefined -fno-sanitize=alignment" ENABLE_UBSAN_OK) + if (NOT ENABLE_UBSAN_OK) + MESSAGE(FATAL_ERROR "The compiler does not support Undefined Behavior Sanitizer") + endif() + if(ENABLE_STATIC_UBSAN AND "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU") + add_compile_options(-static-libubsan) + set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -static-libubsan") + endif() + add_compile_options(-fsanitize=undefined -fno-sanitize=alignment) + add_compile_options(-fno-sanitize-recover=all) # Exit on failure + # TODO(dutor) Remove the following line when RTTI-enabled RocksDB is ready + add_compile_options(-fno-sanitize=vptr) + if(NOT ENABLE_ASAN) + add_compile_options(-g) + add_compile_options(-fno-omit-frame-pointer) + endif() + set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fsanitize=undefined") +endif() + +if(ENABLE_FUZZ_TEST) + check_cxx_compiler_flag("-fsanitize=fuzzer" ENABLE_FUZZ_OK) + if (NOT ENABLE_FUZZ_OK) + MESSAGE(FATAL_ERROR "The compiler does not support fuzz testing") + endif() +endif() diff --git a/cmake/nebula/ThirdPartyConfig.cmake b/cmake/nebula/ThirdPartyConfig.cmake new file mode 100644 index 00000000..838876ff --- /dev/null +++ b/cmake/nebula/ThirdPartyConfig.cmake @@ -0,0 +1,160 @@ +message(">>>> Configuring third party for '${PROJECT_NAME}' <<<<") +# The precedence to decide NEBULA_THIRDPARTY_ROOT is: +# 1. The path defined with CMake argument, i.e -DNEBULA_THIRDPARTY_ROOT=path +# 2. ${CMAKE_BINARY_DIR}/third-party/install, if exists +# 3. The path specified with environment variable NEBULA_THIRDPARTY_ROOT=path +# 4. /opt/vesoft/third-party, if exists +# 5. At last, one copy will be downloaded and installed to ${CMAKE_BINARY_DIR}/third-party/install + +set(NEBULA_THIRDPARTY_VERSION "2.0") + +if(${DISABLE_CXX11_ABI}) + SET(NEBULA_THIRDPARTY_ROOT ${CMAKE_BINARY_DIR}/third-party-98/install) + if(NOT EXISTS ${CMAKE_BINARY_DIR}/third-party-98/install) + message(STATUS "Install abi 98 third-party") + include(InstallThirdParty) + endif() +else() + if("${NEBULA_THIRDPARTY_ROOT}" STREQUAL "") + if(EXISTS ${CMAKE_BINARY_DIR}/third-party/install) + SET(NEBULA_THIRDPARTY_ROOT ${CMAKE_BINARY_DIR}/third-party/install) + elseif(NOT $ENV{NEBULA_THIRDPARTY_ROOT} STREQUAL "") + SET(NEBULA_THIRDPARTY_ROOT $ENV{NEBULA_THIRDPARTY_ROOT}) + elseif(EXISTS /opt/vesoft/third-party/${NEBULA_THIRDPARTY_VERSION}) + SET(NEBULA_THIRDPARTY_ROOT "/opt/vesoft/third-party/${NEBULA_THIRDPARTY_VERSION}") + else() + include(InstallThirdParty) + endif() + endif() +endif() + +if(NOT ${NEBULA_THIRDPARTY_ROOT} STREQUAL "") + print_config(NEBULA_THIRDPARTY_ROOT) + file(READ ${NEBULA_THIRDPARTY_ROOT}/version-info third_party_build_info) + message(STATUS "Build info of nebula third party:\n${third_party_build_info}") + list(INSERT CMAKE_INCLUDE_PATH 0 ${NEBULA_THIRDPARTY_ROOT}/include) + list(INSERT CMAKE_LIBRARY_PATH 0 ${NEBULA_THIRDPARTY_ROOT}/lib) + list(INSERT CMAKE_LIBRARY_PATH 0 ${NEBULA_THIRDPARTY_ROOT}/lib64) + list(INSERT CMAKE_PROGRAM_PATH 0 ${NEBULA_THIRDPARTY_ROOT}/bin) + include_directories(SYSTEM ${NEBULA_THIRDPARTY_ROOT}/include) + link_directories( + ${NEBULA_THIRDPARTY_ROOT}/lib + ${NEBULA_THIRDPARTY_ROOT}/lib64 + ) +endif() + +if(NOT ${NEBULA_OTHER_ROOT} STREQUAL "") + string(REPLACE ":" ";" DIR_LIST ${NEBULA_OTHER_ROOT}) + list(LENGTH DIR_LIST len) + foreach(DIR IN LISTS DIR_LIST ) + list(INSERT CMAKE_INCLUDE_PATH 0 ${DIR}/include) + list(INSERT CMAKE_LIBRARY_PATH 0 ${DIR}/lib) + list(INSERT CMAKE_PROGRAM_PATH 0 ${DIR}/bin) + include_directories(SYSTEM ${DIR}/include) + link_directories(${DIR}/lib) + set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -L ${DIR}/lib") + endforeach() +endif() + +print_config(CMAKE_INCLUDE_PATH) +print_config(CMAKE_LIBRARY_PATH) +print_config(CMAKE_PROGRAM_PATH) + +execute_process( + COMMAND ldd --version + COMMAND head -1 + COMMAND cut -d ")" -f 2 + COMMAND cut -d " " -f 2 + OUTPUT_VARIABLE GLIBC_VERSION + OUTPUT_STRIP_TRAILING_WHITESPACE +) +print_config(GLIBC_VERSION) + +if (GLIBC_VERSION VERSION_LESS "2.17") + set(GETTIME_LIB rt) +else() + set(GETTIME_LIB) +endif() + +message("") + +find_package(Bzip2 REQUIRED) +find_package(DoubleConversion REQUIRED) +find_package(Fatal REQUIRED) +find_package(Fbthrift REQUIRED) +find_package(Folly REQUIRED) +find_package(Gflags REQUIRED) +find_package(Glog REQUIRED) +find_package(Googletest REQUIRED) +if(ENABLE_JEMALLOC) + find_package(Jemalloc REQUIRED) +endif() +find_package(Libevent REQUIRED) +find_package(Proxygen REQUIRED) +find_package(Rocksdb REQUIRED) +find_package(Snappy REQUIRED) +find_package(Wangle REQUIRED) +find_package(ZLIB REQUIRED) +find_package(Zstd REQUIRED) +find_package(OpenSSL REQUIRED) +find_package(Krb5 REQUIRED gssapi) +find_package(Boost REQUIRED) +find_package(Libunwind REQUIRED) +find_package(BISON 3.0.5 REQUIRED) +include(MakeBisonRelocatable) +find_package(FLEX REQUIRED) +find_package(LibLZMA REQUIRED) +find_package(Fizz REQUIRED) +find_package(Sodium REQUIRED) +if (${CMAKE_HOST_SYSTEM_PROCESSOR} MATCHES "x86_64") + find_package(Breakpad REQUIRED) +endif() + +set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -L ${NEBULA_THIRDPARTY_ROOT}/lib") +set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -L ${NEBULA_THIRDPARTY_ROOT}/lib64") + +# All thrift libraries +set(THRIFT_LIBRARIES + thriftcpp2 + rocketupgrade + async + thriftprotocol + transport + concurrency + thriftfrozen2 + thrift-core + rpcmetadata + thriftmetadata + wangle + fizz + sodium +) + +set(PROXYGEN_LIBRARIES + proxygenhttpserver + proxygen + wangle + fizz + sodium +) + +set(ROCKSDB_LIBRARIES ${Rocksdb_LIBRARY}) + +# All compression libraries +set(COMPRESSION_LIBRARIES bz2 snappy zstd z lz4) +if (LIBLZMA_FOUND) + include_directories(SYSTEM ${LIBLZMA_INCLUDE_DIRS}) + list(APPEND COMPRESSION_LIBRARIES ${LIBLZMA_LIBRARIES}) +endif() + +if (NOT ENABLE_JEMALLOC OR ENABLE_ASAN OR ENABLE_UBSAN) + set(JEMALLOC_LIB ) +else() + set(JEMALLOC_LIB jemalloc) +endif() + +if (Breakpad_FOUND) + include_directories(AFTER SYSTEM ${Breakpad_INCLUDE_DIR}/breakpad) +endif() + +message(">>>> Configuring third party for '${PROJECT_NAME}' done <<<<") diff --git a/gen-interface.sh b/gen-interface.sh new file mode 100755 index 00000000..7cf19500 --- /dev/null +++ b/gen-interface.sh @@ -0,0 +1,38 @@ +#! /usr/bin/env bash + +set -e + +NEBULA_THIRDPARYTY_HOME=/opt/vesoft/third-party/2.0 + +# Parsing options from arguments +while getopts "t:" opt; do + case $opt in + t) + NEBULA_THIRDPARYTY_HOME=${OPTARG} + ;; + \?) + echo "Invalid option: -${OPTARG}" >&2 + exit 1 + ;; + :) + echo "Option -${OPTARG} requires an argument." >&2 + exit 1 + ;; + esac +done + +for mod in common meta storage graph; do + wget https://raw.githubusercontent.com/vesoft-inc/nebula/master/src/interface/$mod.thrift +done + +# Strip nebula source +# for mod in common graph; do + # sed -i '/cpp_include/d' $mod.thrift + # sed -i 's/cpp.type = "[^"]\+"//g' $mod.thrift +# done + +for mod in common meta storage graph; do + $NEBULA_THIRDPARYTY_HOME/bin/thrift1 --strict --allow-neg-enum-vals --gen "mstch_cpp2:include_prefix=${include_prefix},stack_arguments" -o ./src/interface/ $mod.thrift +done + +rm common.thrift graph.thrift meta.thrift storage.thrift diff --git a/include/common/datatypes/CommonCpp2Ops.h b/include/common/datatypes/CommonCpp2Ops.h new file mode 100644 index 00000000..bfb4456e --- /dev/null +++ b/include/common/datatypes/CommonCpp2Ops.h @@ -0,0 +1,49 @@ +/* Copyright (c) 2021 vesoft inc. All rights reserved. + * + * This source code is licensed under Apache 2.0 License, + * attached with Common Clause Condition 1.0, found in the LICENSES directory. + */ + +#pragma once + +#include "common/thrift/ThriftCpp2OpsHelper.h" + +namespace nebula { +struct Value; +struct Vertex; +struct Tag; +struct Edge; +struct Step; +struct Path; +struct HostAddr; +struct KeyValue; +struct Date; +struct DateTime; +struct Time; +struct Map; +struct Set; +struct List; +struct DataSet; +struct Geography; +} // namespace nebula + +namespace apache::thrift { + +SPECIALIZE_CPP2OPS(nebula::Value); +SPECIALIZE_CPP2OPS(nebula::Vertex); +SPECIALIZE_CPP2OPS(nebula::Tag); +SPECIALIZE_CPP2OPS(nebula::Edge); +SPECIALIZE_CPP2OPS(nebula::Step); +SPECIALIZE_CPP2OPS(nebula::Path); +SPECIALIZE_CPP2OPS(nebula::HostAddr); +SPECIALIZE_CPP2OPS(nebula::KeyValue); +SPECIALIZE_CPP2OPS(nebula::Date); +SPECIALIZE_CPP2OPS(nebula::Time); +SPECIALIZE_CPP2OPS(nebula::DateTime); +SPECIALIZE_CPP2OPS(nebula::Map); +SPECIALIZE_CPP2OPS(nebula::Set); +SPECIALIZE_CPP2OPS(nebula::List); +SPECIALIZE_CPP2OPS(nebula::DataSet); +SPECIALIZE_CPP2OPS(nebula::Geography); + +} // namespace apache::thrift diff --git a/include/common/datatypes/DataSet.h b/include/common/datatypes/DataSet.h new file mode 100644 index 00000000..b0ffbc4b --- /dev/null +++ b/include/common/datatypes/DataSet.h @@ -0,0 +1,185 @@ +/* Copyright (c) 2020 vesoft inc. All rights reserved. + * + * This source code is licensed under Apache 2.0 License, + * attached with Common Clause Condition 1.0, found in the LICENSES directory. + */ + +#pragma once + +#include +#include +#include +#include + +#include "common/datatypes/List.h" +#include "common/datatypes/Value.h" + +namespace nebula { + +using Row = List; + +struct DataSet { + std::vector colNames; + std::vector rows; + + DataSet() = default; + explicit DataSet(std::vector columns) : colNames(std::move(columns)) {} + DataSet(const DataSet& ds) noexcept { + colNames = ds.colNames; + rows = ds.rows; + } + DataSet(DataSet&& ds) noexcept { + colNames = std::move(ds.colNames); + rows = std::move(ds.rows); + } + DataSet& operator=(const DataSet& ds) noexcept { + if (&ds != this) { + colNames = ds.colNames; + rows = ds.rows; + } + return *this; + } + DataSet& operator=(DataSet&& ds) noexcept { + if (&ds != this) { + colNames = std::move(ds.colNames); + rows = std::move(ds.rows); + } + return *this; + } + + const std::vector& keys() const { + return colNames; + } + + const std::vector& rowValues(std::size_t index) const { + return rows[index].values; + } + + std::vector colValues(const std::string& colName) const { + std::vector col; + const auto find = std::find(colNames.begin(), colNames.end(), colName); + if (find == colNames.end()) { + return col; + } + std::size_t index = std::distance(colNames.begin(), find); + col.reserve(rows.size()); + for (const auto& row : rows) { + col.emplace_back(row.values[index]); + } + return col; + } + + using iterator = std::vector::iterator; + using const_iterator = std::vector::const_iterator; + + iterator begin() { + return rows.begin(); + } + + const_iterator begin() const { + return rows.begin(); + } + + iterator end() { + return rows.end(); + } + + const_iterator end() const { + return rows.end(); + } + + template ::value, T>::type> + bool emplace_back(T&& row) { + if (row.size() != colNames.size()) { + return false; + } + rows.emplace_back(std::forward(row)); + return true; + } + + // append the DataSet to one with same header + bool append(DataSet&& o) { + if (colNames.empty()) { + colNames = std::move(o.colNames); + } else { + if (colNames != o.colNames) { + return false; + } + } + rows.reserve(rowSize() + o.rowSize()); + rows.insert(rows.end(), + std::make_move_iterator(o.rows.begin()), + std::make_move_iterator(o.rows.end())); + return true; + } + + // merge two DataSet Horizontally with same row count + bool merge(DataSet&& o) { + if (rowSize() != o.rowSize()) { + return false; + } + auto newColSize = colSize() + o.colSize(); + colNames.reserve(newColSize); + colNames.insert(colNames.end(), + std::make_move_iterator(o.colNames.begin()), + std::make_move_iterator(o.colNames.end())); + for (std::size_t i = 0; i < rowSize(); ++i) { + rows[i].values.reserve(newColSize); + rows[i].values.insert(rows[i].values.begin(), + std::make_move_iterator(o.rows[i].values.begin()), + std::make_move_iterator(o.rows[i].values.end())); + } + return true; + } + + void clear() { + colNames.clear(); + rows.clear(); + } + + void __clear() { + clear(); + } + + std::size_t size() const { + return rowSize(); + } + + std::size_t rowSize() const { + return rows.size(); + } + + std::size_t colSize() const { + return colNames.size(); + } + + std::string toString() const { + std::stringstream os; + // header + for (const auto& h : colNames) { + os << h << "|"; + } + os << std::endl; + + // body + for (const auto& row : rows) { + for (const auto& col : row.values) { + os << col << "|"; + } + os << std::endl; + } + os << std::endl; + return os.str(); + } + + bool operator==(const DataSet& rhs) const { + return colNames == rhs.colNames && rows == rhs.rows; + } +}; + +inline std::ostream& operator<<(std::ostream& os, const DataSet& d) { + return os << d.toString(); +} + +} // namespace nebula diff --git a/include/common/datatypes/DataSetOps-inl.h b/include/common/datatypes/DataSetOps-inl.h new file mode 100644 index 00000000..f48e80d4 --- /dev/null +++ b/include/common/datatypes/DataSetOps-inl.h @@ -0,0 +1,183 @@ +/* Copyright (c) 2020 vesoft inc. All rights reserved. + * + * This source code is licensed under Apache 2.0 License, + * attached with Common Clause Condition 1.0, found in the LICENSES directory. + */ + +#pragma once + +#include +#include +#include + +#include "common/datatypes/CommonCpp2Ops.h" +#include "common/datatypes/DataSet.h" +#include "common/utils/utils.h" + +namespace apache { +namespace thrift { + +/************************************** + * + * Ops for class DataSet + * + *************************************/ +namespace detail { + +template <> +struct TccStructTraits { + static void translateFieldName(MAYBE_UNUSED folly::StringPiece _fname, + MAYBE_UNUSED int16_t& fid, + MAYBE_UNUSED apache::thrift::protocol::TType& _ftype) { + if (_fname == "column_names") { + fid = 1; + _ftype = apache::thrift::protocol::T_LIST; + } else if (_fname == "rows") { + fid = 2; + _ftype = apache::thrift::protocol::T_LIST; + } + } +}; + +} // namespace detail + +inline constexpr protocol::TType Cpp2Ops::thriftType() { + return apache::thrift::protocol::T_STRUCT; +} + +template +uint32_t Cpp2Ops::write(Protocol* proto, nebula::DataSet const* obj) { + uint32_t xfer = 0; + xfer += proto->writeStructBegin("DataSet"); + + xfer += proto->writeFieldBegin("column_names", protocol::T_LIST, 1); + xfer += detail::pm::protocol_methods, + std::vector>::write(*proto, obj->colNames); + xfer += proto->writeFieldEnd(); + + xfer += proto->writeFieldBegin("rows", apache::thrift::protocol::T_LIST, 2); + xfer += detail::pm::protocol_methods, + std::vector>::write(*proto, obj->rows); + xfer += proto->writeFieldEnd(); + + xfer += proto->writeFieldStop(); + xfer += proto->writeStructEnd(); + return xfer; +} + +template +void Cpp2Ops::read(Protocol* proto, nebula::DataSet* obj) { + apache::thrift::detail::ProtocolReaderStructReadState readState; + + readState.readStructBegin(proto); + + using apache::thrift::protocol::TProtocolException; + + if (UNLIKELY(!readState.advanceToNextField(proto, 0, 1, protocol::T_LIST))) { + goto _loop; + } + +_readField_column_names : { + obj->colNames = std::vector(); + detail::pm::protocol_methods, + std::vector>::read(*proto, obj->colNames); +} + + if (UNLIKELY(!readState.advanceToNextField(proto, 1, 2, protocol::T_LIST))) { + goto _loop; + } + +_readField_rows : { + obj->rows = std::vector(); + detail::pm::protocol_methods, + std::vector>::read(*proto, obj->rows); +} + + if (UNLIKELY(!readState.advanceToNextField(proto, 2, 0, protocol::T_STOP))) { + goto _loop; + } + +_end: + readState.readStructEnd(proto); + + return; + +_loop: + if (readState.fieldType == apache::thrift::protocol::T_STOP) { + goto _end; + } + + if (proto->kUsesFieldNames()) { + detail::TccStructTraits::translateFieldName( + readState.fieldName(), readState.fieldId, readState.fieldType); + } + + switch (readState.fieldId) { + case 1: { + if (LIKELY(readState.fieldType == apache::thrift::protocol::T_LIST)) { + goto _readField_column_names; + } else { + goto _skip; + } + } + case 2: { + if (LIKELY(readState.fieldType == apache::thrift::protocol::T_LIST)) { + goto _readField_rows; + } else { + goto _skip; + } + } + default: { + _skip: + proto->skip(readState.fieldType); + readState.readFieldEnd(proto); + readState.readFieldBeginNoInline(proto); + goto _loop; + } + } +} + +template +uint32_t Cpp2Ops::serializedSize(Protocol const* proto, + nebula::DataSet const* obj) { + uint32_t xfer = 0; + xfer += proto->serializedStructSize("DataSet"); + + xfer += proto->serializedFieldSize("column_names", protocol::T_LIST, 1); + xfer += detail::pm::protocol_methods< + type_class::list, + std::vector>::serializedSize(*proto, obj->colNames); + + xfer += proto->serializedFieldSize("rows", apache::thrift::protocol::T_LIST, 2); + xfer += + detail::pm::protocol_methods, + std::vector>::serializedSize(*proto, + obj->rows); + + xfer += proto->serializedSizeStop(); + return xfer; +} + +template +uint32_t Cpp2Ops::serializedSizeZC(Protocol const* proto, + nebula::DataSet const* obj) { + uint32_t xfer = 0; + xfer += proto->serializedStructSize("DataSet"); + + xfer += proto->serializedFieldSize("column_names", protocol::T_LIST, 1); + xfer += detail::pm::protocol_methods< + type_class::list, + std::vector>::serializedSize(*proto, obj->colNames); + + xfer += proto->serializedFieldSize("rows", protocol::T_LIST, 2); + xfer += + detail::pm::protocol_methods, + std::vector>::serializedSize(*proto, + obj->rows); + + xfer += proto->serializedSizeStop(); + return xfer; +} + +} // namespace thrift +} // namespace apache diff --git a/include/common/datatypes/Date.h b/include/common/datatypes/Date.h new file mode 100644 index 00000000..4e8cc2a7 --- /dev/null +++ b/include/common/datatypes/Date.h @@ -0,0 +1,239 @@ +/* Copyright (c) 2020 vesoft inc. All rights reserved. + * + * This source code is licensed under Apache 2.0 License, + * attached with Common Clause Condition 1.0, found in the LICENSES directory. + */ + +#pragma once + +#include + +namespace nebula { + +// In nebula only store UTC time, and the interpretion of time value based on +// the timezone configuration in current system. + +extern const int64_t kDaysSoFar[]; +extern const int64_t kLeapDaysSoFar[]; + +struct Date { + int16_t year; // Any integer + int8_t month; // 1 - 12 + int8_t day; // 1 - 31 + + Date() : year{0}, month{1}, day{1} {} + Date(int16_t y, int8_t m, int8_t d) : year{y}, month{m}, day{d} {} + // Tak the number of days since -32768/1/1, and convert to the real date + explicit Date(uint64_t days); + + void clear() { + year = 0; + month = 1; + day = 1; + } + + void __clear() { + clear(); + } + + void reset(int16_t y, int8_t m, int8_t d) { + year = y; + month = m; + day = d; + } + + bool operator==(const Date& rhs) const { + return year == rhs.year && month == rhs.month && day == rhs.day; + } + + bool operator<(const Date& rhs) const { + if (!(year == rhs.year)) { + return year < rhs.year; + } + if (!(month == rhs.month)) { + return month < rhs.month; + } + if (!(day == rhs.day)) { + return day < rhs.day; + } + return false; + } + + Date operator+(int64_t days) const; + Date operator-(int64_t days) const; + + std::string toString() const; + + // Return the number of days since -32768/1/1 + int64_t toInt() const; + // Convert the number of days since -32768/1/1 to the real date + void fromInt(int64_t days); +}; + +inline std::ostream& operator<<(std::ostream& os, const Date& d) { + os << d.toString(); + return os; +} + +struct Time { + int8_t hour; + int8_t minute; + int8_t sec; + int32_t microsec; + + Time() : hour{0}, minute{0}, sec{0}, microsec{0} {} + Time(int8_t h, int8_t min, int8_t s, int32_t us) : hour{h}, minute{min}, sec{s}, microsec{us} {} + + void clear() { + hour = 0; + minute = 0; + sec = 0; + microsec = 0; + } + + void __clear() { + clear(); + } + + bool operator==(const Time& rhs) const { + return hour == rhs.hour && minute == rhs.minute && sec == rhs.sec && + microsec == rhs.microsec; + } + + bool operator<(const Time& rhs) const { + if (!(hour == rhs.hour)) { + return hour < rhs.hour; + } + if (!(minute == rhs.minute)) { + return minute < rhs.minute; + } + if (!(sec == rhs.sec)) { + return sec < rhs.sec; + } + if (!(microsec == rhs.microsec)) { + return microsec < rhs.microsec; + } + return false; + } + + std::string toString() const; +}; + +inline std::ostream& operator<<(std::ostream& os, const Time& d) { + os << d.toString(); + return os; +} + +struct DateTime { +#if defined(__GNUC__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wpedantic" +#endif // defined(__GNUC__) + union { + struct { + int64_t year : 16; + uint64_t month : 4; + uint64_t day : 5; + uint64_t hour : 5; + uint64_t minute : 6; + uint64_t sec : 6; + uint64_t microsec : 22; + }; + uint64_t qword; + }; +#if defined(__GNUC__) +#pragma GCC diagnostic pop +#endif // defined(__GNUC__) + + DateTime() : year{0}, month{1}, day{1}, hour{0}, minute{0}, sec{0}, microsec{0} {} + DateTime(int16_t y, int8_t m, int8_t d, int8_t h, int8_t min, int8_t s, int32_t us) { + year = y; + month = m; + day = d; + hour = h; + minute = min; + sec = s; + microsec = us; + } + explicit DateTime(const Date& date) { + year = date.year; + month = date.month; + day = date.day; + hour = 0; + minute = 0; + sec = 0; + microsec = 0; + } + + void clear() { + year = 0; + month = 1; + day = 1; + hour = 0; + minute = 0; + sec = 0; + microsec = 0; + } + + void __clear() { + clear(); + } + + bool operator==(const DateTime& rhs) const { + return year == rhs.year && month == rhs.month && day == rhs.day && hour == rhs.hour && + minute == rhs.minute && sec == rhs.sec && microsec == rhs.microsec; + } + bool operator<(const DateTime& rhs) const { + if (!(year == rhs.year)) { + return year < rhs.year; + } + if (!(month == rhs.month)) { + return month < rhs.month; + } + if (!(day == rhs.day)) { + return day < rhs.day; + } + if (!(hour == rhs.hour)) { + return hour < rhs.hour; + } + if (!(minute == rhs.minute)) { + return minute < rhs.minute; + } + if (!(sec == rhs.sec)) { + return sec < rhs.sec; + } + if (!(microsec == rhs.microsec)) { + return microsec < rhs.microsec; + } + return false; + } + + std::string toString() const; +}; + +inline std::ostream& operator<<(std::ostream& os, const DateTime& d) { + os << d.toString(); + return os; +} + +} // namespace nebula + +namespace std { + +// Inject a customized hash function +template <> +struct hash { + std::size_t operator()(const nebula::Date& h) const noexcept; +}; + +template <> +struct hash { + std::size_t operator()(const nebula::Time& h) const noexcept; +}; + +template <> +struct hash { + std::size_t operator()(const nebula::DateTime& h) const noexcept; +}; + +} // namespace std diff --git a/include/common/datatypes/DateOps-inl.h b/include/common/datatypes/DateOps-inl.h new file mode 100644 index 00000000..3c6a336d --- /dev/null +++ b/include/common/datatypes/DateOps-inl.h @@ -0,0 +1,724 @@ +/* Copyright (c) 2020 vesoft inc. All rights reserved. + * + * This source code is licensed under Apache 2.0 License, + * attached with Common Clause Condition 1.0, found in the LICENSES directory. + */ + +#pragma once + +#include +#include +#include + +#include "common/datatypes/CommonCpp2Ops.h" +#include "common/datatypes/Date.h" +#include "common/utils/utils.h" + +namespace apache { +namespace thrift { + +/************************************** + * + * Ops for class Date + * + *************************************/ +namespace detail { + +template <> +struct TccStructTraits { + static void translateFieldName(MAYBE_UNUSED folly::StringPiece _fname, + MAYBE_UNUSED int16_t& fid, + MAYBE_UNUSED apache::thrift::protocol::TType& _ftype) { + if (_fname == "year") { + fid = 1; + _ftype = apache::thrift::protocol::T_I16; + } else if (_fname == "month") { + fid = 2; + _ftype = apache::thrift::protocol::T_BYTE; + } else if (_fname == "day") { + fid = 3; + _ftype = apache::thrift::protocol::T_BYTE; + } + } +}; + +} // namespace detail + +inline constexpr protocol::TType Cpp2Ops::thriftType() { + return apache::thrift::protocol::T_STRUCT; +} + +template +uint32_t Cpp2Ops::write(Protocol* proto, nebula::Date const* obj) { + uint32_t xfer = 0; + xfer += proto->writeStructBegin("Date"); + + xfer += proto->writeFieldBegin("year", apache::thrift::protocol::T_I16, 1); + xfer += detail::pm::protocol_methods::write(*proto, obj->year); + xfer += proto->writeFieldEnd(); + + xfer += proto->writeFieldBegin("month", apache::thrift::protocol::T_BYTE, 2); + xfer += detail::pm::protocol_methods::write(*proto, obj->month); + xfer += proto->writeFieldEnd(); + + xfer += proto->writeFieldBegin("day", apache::thrift::protocol::T_BYTE, 3); + xfer += detail::pm::protocol_methods::write(*proto, obj->day); + xfer += proto->writeFieldEnd(); + + xfer += proto->writeFieldStop(); + xfer += proto->writeStructEnd(); + + return xfer; +} + +template +void Cpp2Ops::read(Protocol* proto, nebula::Date* obj) { + detail::ProtocolReaderStructReadState readState; + + readState.readStructBegin(proto); + + using apache::thrift::protocol::TProtocolException; + + if (UNLIKELY(!readState.advanceToNextField(proto, 0, 1, protocol::T_I16))) { + goto _loop; + } + +_readField_year : { + detail::pm::protocol_methods::read(*proto, obj->year); +} + + if (UNLIKELY(!readState.advanceToNextField(proto, 1, 2, protocol::T_BYTE))) { + goto _loop; + } + +_readField_month : { + detail::pm::protocol_methods::read(*proto, obj->month); +} + + if (UNLIKELY(!readState.advanceToNextField(proto, 2, 3, protocol::T_BYTE))) { + goto _loop; + } + +_readField_day : { + detail::pm::protocol_methods::read(*proto, obj->day); +} + + if (UNLIKELY(!readState.advanceToNextField(proto, 3, 0, protocol::T_STOP))) { + goto _loop; + } + +_end: + readState.readStructEnd(proto); + + return; + +_loop: + if (readState.fieldType == apache::thrift::protocol::T_STOP) { + goto _end; + } + if (proto->kUsesFieldNames()) { + detail::TccStructTraits::translateFieldName( + readState.fieldName(), readState.fieldId, readState.fieldType); + } + + switch (readState.fieldId) { + case 1: { + if (LIKELY(readState.fieldType == apache::thrift::protocol::T_I16)) { + goto _readField_year; + } else { + goto _skip; + } + } + case 2: { + if (LIKELY(readState.fieldType == apache::thrift::protocol::T_BYTE)) { + goto _readField_month; + } else { + goto _skip; + } + } + case 3: { + if (LIKELY(readState.fieldType == apache::thrift::protocol::T_BYTE)) { + goto _readField_day; + } else { + goto _skip; + } + } + default: { + _skip: + proto->skip(readState.fieldType); + readState.readFieldEnd(proto); + readState.readFieldBeginNoInline(proto); + goto _loop; + } + } +} + +template +uint32_t Cpp2Ops::serializedSize(Protocol const* proto, nebula::Date const* obj) { + uint32_t xfer = 0; + xfer += proto->serializedStructSize("Date"); + + xfer += proto->serializedFieldSize("year", apache::thrift::protocol::T_I16, 1); + xfer += detail::pm::protocol_methods::serializedSize( + *proto, obj->year); + + xfer += proto->serializedFieldSize("month", apache::thrift::protocol::T_BYTE, 2); + xfer += detail::pm::protocol_methods::serializedSize( + *proto, obj->month); + + xfer += proto->serializedFieldSize("day", apache::thrift::protocol::T_BYTE, 3); + xfer += detail::pm::protocol_methods::serializedSize( + *proto, obj->day); + + xfer += proto->serializedSizeStop(); + return xfer; +} + +template +uint32_t Cpp2Ops::serializedSizeZC(Protocol const* proto, nebula::Date const* obj) { + uint32_t xfer = 0; + xfer += proto->serializedStructSize("Date"); + + xfer += proto->serializedFieldSize("year", apache::thrift::protocol::T_I16, 1); + xfer += detail::pm::protocol_methods::serializedSize( + *proto, obj->year); + + xfer += proto->serializedFieldSize("month", apache::thrift::protocol::T_BYTE, 2); + xfer += detail::pm::protocol_methods::serializedSize( + *proto, obj->month); + + xfer += proto->serializedFieldSize("day", apache::thrift::protocol::T_BYTE, 3); + xfer += detail::pm::protocol_methods::serializedSize( + *proto, obj->day); + + xfer += proto->serializedSizeStop(); + return xfer; +} + +/************************************** + * + * Ops for class Time + * + *************************************/ +namespace detail { + +template <> +struct TccStructTraits { + static void translateFieldName(MAYBE_UNUSED folly::StringPiece _fname, + MAYBE_UNUSED int16_t& fid, + MAYBE_UNUSED apache::thrift::protocol::TType& _ftype) { + if (_fname == "hour") { + fid = 1; + _ftype = apache::thrift::protocol::T_BYTE; + } else if (_fname == "minute") { + fid = 2; + _ftype = apache::thrift::protocol::T_BYTE; + } else if (_fname == "sec") { + fid = 3; + _ftype = apache::thrift::protocol::T_BYTE; + } else if (_fname == "microsec") { + fid = 4; + _ftype = apache::thrift::protocol::T_I32; + } + } +}; + +} // namespace detail + +inline constexpr protocol::TType Cpp2Ops::thriftType() { + return apache::thrift::protocol::T_STRUCT; +} + +template +uint32_t Cpp2Ops::write(Protocol* proto, nebula::Time const* obj) { + uint32_t xfer = 0; + xfer += proto->writeStructBegin("Time"); + + xfer += proto->writeFieldBegin("hour", apache::thrift::protocol::T_BYTE, 1); + xfer += detail::pm::protocol_methods::write(*proto, obj->hour); + xfer += proto->writeFieldEnd(); + + xfer += proto->writeFieldBegin("minute", apache::thrift::protocol::T_BYTE, 2); + xfer += detail::pm::protocol_methods::write(*proto, obj->minute); + xfer += proto->writeFieldEnd(); + + xfer += proto->writeFieldBegin("sec", apache::thrift::protocol::T_BYTE, 3); + xfer += detail::pm::protocol_methods::write(*proto, obj->sec); + xfer += proto->writeFieldEnd(); + + xfer += proto->writeFieldBegin("microsec", apache::thrift::protocol::T_I32, 4); + xfer += + detail::pm::protocol_methods::write(*proto, obj->microsec); + xfer += proto->writeFieldEnd(); + + xfer += proto->writeFieldStop(); + xfer += proto->writeStructEnd(); + return xfer; +} + +template +void Cpp2Ops::read(Protocol* proto, nebula::Time* obj) { + detail::ProtocolReaderStructReadState readState; + + readState.readStructBegin(proto); + + using apache::thrift::protocol::TProtocolException; + + if (UNLIKELY(!readState.advanceToNextField(proto, 0, 1, protocol::T_I16))) { + goto _loop; + } + +_readField_hour : { + detail::pm::protocol_methods::read(*proto, obj->hour); +} + + if (UNLIKELY(!readState.advanceToNextField(proto, 1, 2, protocol::T_BYTE))) { + goto _loop; + } + +_readField_minute : { + detail::pm::protocol_methods::read(*proto, obj->minute); +} + + if (UNLIKELY(!readState.advanceToNextField(proto, 2, 3, protocol::T_BYTE))) { + goto _loop; + } + +_readField_sec : { + detail::pm::protocol_methods::read(*proto, obj->sec); +} + + if (UNLIKELY(!readState.advanceToNextField(proto, 3, 4, protocol::T_I32))) { + goto _loop; + } + +_readField_microsec : { + detail::pm::protocol_methods::read(*proto, obj->microsec); +} + + if (UNLIKELY(!readState.advanceToNextField(proto, 4, 5, protocol::T_I32))) { + goto _loop; + } + +_end: + readState.readStructEnd(proto); + + return; + +_loop: + if (readState.fieldType == apache::thrift::protocol::T_STOP) { + goto _end; + } + + if (proto->kUsesFieldNames()) { + detail::TccStructTraits::translateFieldName( + readState.fieldName(), readState.fieldId, readState.fieldType); + } + + switch (readState.fieldId) { + case 1: { + if (LIKELY(readState.fieldType == apache::thrift::protocol::T_BYTE)) { + goto _readField_hour; + } else { + goto _skip; + } + } + case 2: { + if (LIKELY(readState.fieldType == apache::thrift::protocol::T_BYTE)) { + goto _readField_minute; + } else { + goto _skip; + } + } + case 3: { + if (LIKELY(readState.fieldType == apache::thrift::protocol::T_BYTE)) { + goto _readField_sec; + } else { + goto _skip; + } + } + case 4: { + if (LIKELY(readState.fieldType == apache::thrift::protocol::T_I32)) { + goto _readField_microsec; + } else { + goto _skip; + } + } + default: { + _skip: + proto->skip(readState.fieldType); + readState.readFieldEnd(proto); + readState.readFieldBeginNoInline(proto); + goto _loop; + } + } +} + +template +uint32_t Cpp2Ops::serializedSize(Protocol const* proto, nebula::Time const* obj) { + uint32_t xfer = 0; + xfer += proto->serializedStructSize("Time"); + + xfer += proto->serializedFieldSize("hour", apache::thrift::protocol::T_BYTE, 1); + xfer += detail::pm::protocol_methods::serializedSize( + *proto, obj->hour); + + xfer += proto->serializedFieldSize("minute", apache::thrift::protocol::T_BYTE, 2); + xfer += detail::pm::protocol_methods::serializedSize( + *proto, obj->minute); + + xfer += proto->serializedFieldSize("sec", apache::thrift::protocol::T_BYTE, 3); + xfer += detail::pm::protocol_methods::serializedSize( + *proto, obj->sec); + + xfer += proto->serializedFieldSize("microsec", apache::thrift::protocol::T_I32, 4); + xfer += detail::pm::protocol_methods::serializedSize( + *proto, obj->microsec); + + xfer += proto->serializedSizeStop(); + return xfer; +} + +template +uint32_t Cpp2Ops::serializedSizeZC(Protocol const* proto, nebula::Time const* obj) { + uint32_t xfer = 0; + xfer += proto->serializedStructSize("Time"); + + xfer += proto->serializedFieldSize("hour", apache::thrift::protocol::T_BYTE, 1); + xfer += detail::pm::protocol_methods::serializedSize( + *proto, obj->hour); + + xfer += proto->serializedFieldSize("minute", apache::thrift::protocol::T_BYTE, 2); + xfer += detail::pm::protocol_methods::serializedSize( + *proto, obj->minute); + + xfer += proto->serializedFieldSize("sec", apache::thrift::protocol::T_BYTE, 3); + xfer += detail::pm::protocol_methods::serializedSize( + *proto, obj->sec); + + xfer += proto->serializedFieldSize("microsec", apache::thrift::protocol::T_I32, 4); + xfer += detail::pm::protocol_methods::serializedSize( + *proto, obj->microsec); + + xfer += proto->serializedSizeStop(); + return xfer; +} + +/************************************** + * + * Ops for class DateTime + * + *************************************/ +namespace detail { + +template <> +struct TccStructTraits { + static void translateFieldName(MAYBE_UNUSED folly::StringPiece _fname, + MAYBE_UNUSED int16_t& fid, + MAYBE_UNUSED apache::thrift::protocol::TType& _ftype) { + if (_fname == "year") { + fid = 1; + _ftype = apache::thrift::protocol::T_I16; + } else if (_fname == "month") { + fid = 2; + _ftype = apache::thrift::protocol::T_BYTE; + } else if (_fname == "day") { + fid = 3; + _ftype = apache::thrift::protocol::T_BYTE; + } else if (_fname == "hour") { + fid = 4; + _ftype = apache::thrift::protocol::T_BYTE; + } else if (_fname == "minute") { + fid = 5; + _ftype = apache::thrift::protocol::T_BYTE; + } else if (_fname == "sec") { + fid = 6; + _ftype = apache::thrift::protocol::T_BYTE; + } else if (_fname == "microsec") { + fid = 7; + _ftype = apache::thrift::protocol::T_I32; + } + } +}; + +} // namespace detail + +inline constexpr protocol::TType Cpp2Ops::thriftType() { + return apache::thrift::protocol::T_STRUCT; +} + +template +uint32_t Cpp2Ops::write(Protocol* proto, nebula::DateTime const* obj) { + uint32_t xfer = 0; + xfer += proto->writeStructBegin("DateTime"); + + xfer += proto->writeFieldBegin("year", apache::thrift::protocol::T_I16, 1); + xfer += detail::pm::protocol_methods::write(*proto, obj->year); + xfer += proto->writeFieldEnd(); + + xfer += proto->writeFieldBegin("month", apache::thrift::protocol::T_BYTE, 2); + xfer += detail::pm::protocol_methods::write(*proto, + obj->month); + xfer += proto->writeFieldEnd(); + + xfer += proto->writeFieldBegin("day", apache::thrift::protocol::T_BYTE, 3); + xfer += detail::pm::protocol_methods::write(*proto, obj->day); + xfer += proto->writeFieldEnd(); + + xfer += proto->writeFieldBegin("hour", apache::thrift::protocol::T_BYTE, 4); + xfer += detail::pm::protocol_methods::write(*proto, obj->hour); + xfer += proto->writeFieldEnd(); + + xfer += proto->writeFieldBegin("minute", apache::thrift::protocol::T_BYTE, 5); + xfer += detail::pm::protocol_methods::write(*proto, obj->minute); + xfer += proto->writeFieldEnd(); + + xfer += proto->writeFieldBegin("sec", apache::thrift::protocol::T_BYTE, 6); + xfer += detail::pm::protocol_methods::write(*proto, obj->sec); + xfer += proto->writeFieldEnd(); + + xfer += proto->writeFieldBegin("microsec", apache::thrift::protocol::T_I32, 7); + xfer += + detail::pm::protocol_methods::write(*proto, obj->microsec); + xfer += proto->writeFieldEnd(); + + xfer += proto->writeFieldStop(); + xfer += proto->writeStructEnd(); + return xfer; +} + +template +void Cpp2Ops::read(Protocol* proto, nebula::DateTime* obj) { + detail::ProtocolReaderStructReadState readState; + + readState.readStructBegin(proto); + + using apache::thrift::protocol::TProtocolException; + + if (UNLIKELY(!readState.advanceToNextField(proto, 0, 1, protocol::T_I16))) { + goto _loop; + } + +_readField_year : { + int16_t year; + detail::pm::protocol_methods::read(*proto, year); + obj->year = year; +} + + if (UNLIKELY(!readState.advanceToNextField(proto, 1, 2, protocol::T_BYTE))) { + goto _loop; + } + +_readField_month : { + int8_t month; + detail::pm::protocol_methods::read(*proto, month); + obj->month = month; +} + + if (UNLIKELY(!readState.advanceToNextField(proto, 2, 3, protocol::T_BYTE))) { + goto _loop; + } + +_readField_day : { + int8_t day; + detail::pm::protocol_methods::read(*proto, day); + obj->day = day; +} + + if (UNLIKELY(!readState.advanceToNextField(proto, 3, 4, protocol::T_BYTE))) { + goto _loop; + } + +_readField_hour : { + int8_t hour; + detail::pm::protocol_methods::read(*proto, hour); + obj->hour = hour; +} + + if (UNLIKELY(!readState.advanceToNextField(proto, 4, 5, protocol::T_BYTE))) { + goto _loop; + } + +_readField_minute : { + int8_t minute; + detail::pm::protocol_methods::read(*proto, minute); + obj->minute = minute; +} + + if (UNLIKELY(!readState.advanceToNextField(proto, 5, 6, protocol::T_BYTE))) { + goto _loop; + } + +_readField_sec : { + int8_t sec; + detail::pm::protocol_methods::read(*proto, sec); + obj->sec = sec; +} + + if (UNLIKELY(!readState.advanceToNextField(proto, 6, 7, protocol::T_I32))) { + goto _loop; + } + +_readField_microsec : { + int32_t microsec; + detail::pm::protocol_methods::read(*proto, microsec); + obj->microsec = microsec; +} + + if (UNLIKELY(!readState.advanceToNextField(proto, 7, 8, protocol::T_I32))) { + goto _loop; + } + +_end: + readState.readStructEnd(proto); + + return; + +_loop: + if (readState.fieldType == apache::thrift::protocol::T_STOP) { + goto _end; + } + + if (proto->kUsesFieldNames()) { + detail::TccStructTraits::translateFieldName( + readState.fieldName(), readState.fieldId, readState.fieldType); + } + + switch (readState.fieldId) { + case 1: { + if (LIKELY(readState.fieldType == apache::thrift::protocol::T_I16)) { + goto _readField_year; + } else { + goto _skip; + } + } + case 2: { + if (LIKELY(readState.fieldType == apache::thrift::protocol::T_BYTE)) { + goto _readField_month; + } else { + goto _skip; + } + } + case 3: { + if (LIKELY(readState.fieldType == apache::thrift::protocol::T_BYTE)) { + goto _readField_day; + } else { + goto _skip; + } + } + case 4: { + if (LIKELY(readState.fieldType == apache::thrift::protocol::T_BYTE)) { + goto _readField_hour; + } else { + goto _skip; + } + } + case 5: { + if (LIKELY(readState.fieldType == apache::thrift::protocol::T_BYTE)) { + goto _readField_minute; + } else { + goto _skip; + } + } + case 6: { + if (LIKELY(readState.fieldType == apache::thrift::protocol::T_BYTE)) { + goto _readField_sec; + } else { + goto _skip; + } + } + case 7: { + if (LIKELY(readState.fieldType == apache::thrift::protocol::T_I32)) { + goto _readField_microsec; + } else { + goto _skip; + } + } + default: { + _skip: + proto->skip(readState.fieldType); + readState.readFieldEnd(proto); + readState.readFieldBeginNoInline(proto); + goto _loop; + } + } +} + +template +uint32_t Cpp2Ops::serializedSize(Protocol const* proto, + nebula::DateTime const* obj) { + uint32_t xfer = 0; + xfer += proto->serializedStructSize("DateTime"); + + xfer += proto->serializedFieldSize("year", apache::thrift::protocol::T_I16, 1); + xfer += detail::pm::protocol_methods::serializedSize( + *proto, obj->year); + + xfer += proto->serializedFieldSize("month", apache::thrift::protocol::T_BYTE, 2); + xfer += detail::pm::protocol_methods::serializedSize( + *proto, obj->month); + + xfer += proto->serializedFieldSize("day", apache::thrift::protocol::T_BYTE, 3); + xfer += detail::pm::protocol_methods::serializedSize( + *proto, obj->day); + + xfer += proto->serializedFieldSize("hour", apache::thrift::protocol::T_BYTE, 4); + xfer += detail::pm::protocol_methods::serializedSize( + *proto, obj->hour); + + xfer += proto->serializedFieldSize("minute", apache::thrift::protocol::T_BYTE, 5); + xfer += detail::pm::protocol_methods::serializedSize( + *proto, obj->minute); + + xfer += proto->serializedFieldSize("sec", apache::thrift::protocol::T_BYTE, 6); + xfer += detail::pm::protocol_methods::serializedSize( + *proto, obj->sec); + + xfer += proto->serializedFieldSize("microsec", apache::thrift::protocol::T_I32, 7); + xfer += detail::pm::protocol_methods::serializedSize( + *proto, obj->microsec); + + xfer += proto->serializedSizeStop(); + return xfer; +} + +template +uint32_t Cpp2Ops::serializedSizeZC(Protocol const* proto, + nebula::DateTime const* obj) { + uint32_t xfer = 0; + xfer += proto->serializedStructSize("DateTime"); + + xfer += proto->serializedFieldSize("year", apache::thrift::protocol::T_I16, 1); + xfer += detail::pm::protocol_methods::serializedSize( + *proto, obj->year); + + xfer += proto->serializedFieldSize("month", apache::thrift::protocol::T_BYTE, 2); + xfer += detail::pm::protocol_methods::serializedSize( + *proto, obj->month); + + xfer += proto->serializedFieldSize("day", apache::thrift::protocol::T_BYTE, 3); + xfer += detail::pm::protocol_methods::serializedSize( + *proto, obj->day); + + xfer += proto->serializedFieldSize("hour", apache::thrift::protocol::T_BYTE, 4); + xfer += detail::pm::protocol_methods::serializedSize( + *proto, obj->hour); + + xfer += proto->serializedFieldSize("minute", apache::thrift::protocol::T_BYTE, 5); + xfer += detail::pm::protocol_methods::serializedSize( + *proto, obj->minute); + + xfer += proto->serializedFieldSize("sec", apache::thrift::protocol::T_BYTE, 6); + xfer += detail::pm::protocol_methods::serializedSize( + *proto, obj->sec); + + xfer += proto->serializedFieldSize("microsec", apache::thrift::protocol::T_I32, 7); + xfer += detail::pm::protocol_methods::serializedSize( + *proto, obj->microsec); + + xfer += proto->serializedSizeStop(); + return xfer; +} + +} // namespace thrift +} // namespace apache diff --git a/include/common/datatypes/Edge.h b/include/common/datatypes/Edge.h new file mode 100644 index 00000000..28b02e6f --- /dev/null +++ b/include/common/datatypes/Edge.h @@ -0,0 +1,86 @@ +/* Copyright (c) 2020 vesoft inc. All rights reserved. + * + * This source code is licensed under Apache 2.0 License, + * attached with Common Clause Condition 1.0, found in the LICENSES directory. + */ + +#pragma once + +#include + +#include "common/datatypes/Value.h" +#include "common/thrift/ThriftTypes.h" + +namespace nebula { + +struct Edge { + Value src; + Value dst; + EdgeType type; + std::string name; + EdgeRanking ranking; + std::unordered_map props; + + Edge() {} + Edge(Edge&& v) noexcept + : src(std::move(v.src)), + dst(std::move(v.dst)), + type(std::move(v.type)), + name(std::move(v.name)), + ranking(std::move(v.ranking)), + props(std::move(v.props)) {} + Edge(const Edge& v) + : src(v.src), dst(v.dst), type(v.type), name(v.name), ranking(v.ranking), props(v.props) {} + Edge(Value s, + Value d, + EdgeType t, + std::string n, + EdgeRanking r, + std::unordered_map&& p) + : src(std::move(s)), + dst(std::move(d)), + type(std::move(t)), + name(std::move(n)), + ranking(std::move(r)), + props(std::move(p)) {} + + void clear(); + + void __clear() { + clear(); + } + + std::string toString() const; + + bool operator==(const Edge& rhs) const; + + void format() { + if (type < 0) { + reverse(); + } + } + + void reverse(); + + bool operator<(const Edge& rhs) const; + + bool contains(const Value& key) const; + + const Value& value(const std::string& key) const; +}; + +inline std::ostream& operator<<(std::ostream& os, const Edge& v) { + return os << v.toString(); +} + +} // namespace nebula + +namespace std { + +// Inject a customized hash function +template <> +struct hash { + std::size_t operator()(const nebula::Edge& h) const noexcept; +}; + +} // namespace std diff --git a/include/common/datatypes/EdgeOps-inl.h b/include/common/datatypes/EdgeOps-inl.h new file mode 100644 index 00000000..8b966b92 --- /dev/null +++ b/include/common/datatypes/EdgeOps-inl.h @@ -0,0 +1,291 @@ +/* Copyright (c) 2020 vesoft inc. All rights reserved. + * + * obj source code is licensed under Apache 2.0 License, + * attached with Common Clause Condition 1.0, found in the LICENSES directory. + */ + +#pragma once + +#include +#include +#include + +#include "common/datatypes/CommonCpp2Ops.h" +#include "common/datatypes/Edge.h" +#include "common/utils/utils.h" + +namespace apache { +namespace thrift { + +namespace detail { + +template <> +struct TccStructTraits { + static void translateFieldName(MAYBE_UNUSED folly::StringPiece _fname, + MAYBE_UNUSED int16_t& fid, + MAYBE_UNUSED apache::thrift::protocol::TType& _ftype) { + if (_fname == "src") { + fid = 1; + _ftype = apache::thrift::protocol::T_STRUCT; + } else if (_fname == "dst") { + fid = 2; + _ftype = apache::thrift::protocol::T_STRUCT; + } else if (_fname == "type") { + fid = 3; + _ftype = apache::thrift::protocol::T_I32; + } else if (_fname == "name") { + fid = 4; + _ftype = apache::thrift::protocol::T_STRING; + } else if (_fname == "ranking") { + fid = 5; + _ftype = apache::thrift::protocol::T_I64; + } else if (_fname == "props") { + fid = 6; + _ftype = apache::thrift::protocol::T_MAP; + } + } +}; + +} // namespace detail + +inline constexpr protocol::TType Cpp2Ops::thriftType() { + return apache::thrift::protocol::T_STRUCT; +} + +template +uint32_t Cpp2Ops::write(Protocol* proto, nebula::Edge const* obj) { + uint32_t xfer = 0; + xfer += proto->writeStructBegin("Edge"); + + xfer += proto->writeFieldBegin("src", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::Cpp2Ops::write(proto, &obj->src); + xfer += proto->writeFieldEnd(); + + xfer += proto->writeFieldBegin("dst", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::Cpp2Ops::write(proto, &obj->dst); + xfer += proto->writeFieldEnd(); + + xfer += proto->writeFieldBegin("type", apache::thrift::protocol::T_I32, 3); + // NOTICE: The original id will be transformed to +1/-1, to indicate the edge + // direction. + auto type = obj->type; + if (type != 0) { + type > 0 ? type = 1 : type = -1; + } + xfer += + detail::pm::protocol_methods::write(*proto, type); + xfer += proto->writeFieldEnd(); + + xfer += proto->writeFieldBegin("name", apache::thrift::protocol::T_STRING, 4); + xfer += proto->writeBinary(obj->name); + xfer += proto->writeFieldEnd(); + + xfer += proto->writeFieldBegin("ranking", apache::thrift::protocol::T_I64, 5); + xfer += detail::pm::protocol_methods::write( + *proto, obj->ranking); + xfer += proto->writeFieldEnd(); + + xfer += proto->writeFieldBegin("props", apache::thrift::protocol::T_MAP, 6); + xfer += detail::pm::protocol_methods< + type_class::map, + std::unordered_map>::write(*proto, obj->props); + xfer += proto->writeFieldEnd(); + + xfer += proto->writeFieldStop(); + xfer += proto->writeStructEnd(); + return xfer; +} + +template +void Cpp2Ops::read(Protocol* proto, nebula::Edge* obj) { + detail::ProtocolReaderStructReadState readState; + + readState.readStructBegin(proto); + + using apache::thrift::protocol::TProtocolException; + if (UNLIKELY(!readState.advanceToNextField(proto, 0, 1, protocol::T_STRUCT))) { + goto _loop; + } + +_readField_src : { ::apache::thrift::Cpp2Ops::read(proto, &obj->src); } + + if (UNLIKELY(!readState.advanceToNextField(proto, 1, 2, protocol::T_STRUCT))) { + goto _loop; + } + +_readField_dst : { ::apache::thrift::Cpp2Ops::read(proto, &obj->dst); } + + if (UNLIKELY(!readState.advanceToNextField(proto, 2, 3, protocol::T_I32))) { + goto _loop; + } + +_readField_type : { + detail::pm::protocol_methods::read(*proto, obj->type); +} + + if (UNLIKELY(!readState.advanceToNextField(proto, 3, 4, protocol::T_STRING))) { + goto _loop; + } + +_readField_name : { proto->readBinary(obj->name); } + + if (UNLIKELY(!readState.advanceToNextField(proto, 4, 5, protocol::T_I64))) { + goto _loop; + } + +_readField_ranking : { + detail::pm::protocol_methods::read(*proto, + obj->ranking); +} + + if (UNLIKELY(!readState.advanceToNextField(proto, 5, 6, protocol::T_MAP))) { + goto _loop; + } + +_readField_props : { + obj->props = std::unordered_map(); + detail::pm::protocol_methods, + std::unordered_map>::read(*proto, + obj->props); +} + + if (UNLIKELY(!readState.advanceToNextField(proto, 6, 0, protocol::T_STOP))) { + goto _loop; + } + +_end: + readState.readStructEnd(proto); + + return; + +_loop: + if (readState.fieldType == apache::thrift::protocol::T_STOP) { + goto _end; + } + + if (proto->kUsesFieldNames()) { + detail::TccStructTraits::translateFieldName( + readState.fieldName(), readState.fieldId, readState.fieldType); + } + + switch (readState.fieldId) { + case 1: { + if (LIKELY(readState.fieldType == apache::thrift::protocol::T_STRUCT)) { + goto _readField_src; + } else { + goto _skip; + } + } + case 2: { + if (LIKELY(readState.fieldType == apache::thrift::protocol::T_STRUCT)) { + goto _readField_dst; + } else { + goto _skip; + } + } + case 3: { + if (LIKELY(readState.fieldType == apache::thrift::protocol::T_I32)) { + goto _readField_type; + } else { + goto _skip; + } + } + case 4: { + if (LIKELY(readState.fieldType == apache::thrift::protocol::T_STRING)) { + goto _readField_name; + } else { + goto _skip; + } + } + case 5: { + if (LIKELY(readState.fieldType == apache::thrift::protocol::T_I64)) { + goto _readField_ranking; + } else { + goto _skip; + } + } + case 6: { + if (LIKELY(readState.fieldType == apache::thrift::protocol::T_MAP)) { + goto _readField_props; + } else { + goto _skip; + } + } + default: { + _skip: + proto->skip(readState.fieldType); + readState.readFieldEnd(proto); + readState.readFieldBeginNoInline(proto); + goto _loop; + } + } +} + +template +uint32_t Cpp2Ops::serializedSize(Protocol const* proto, nebula::Edge const* obj) { + uint32_t xfer = 0; + xfer += proto->serializedStructSize("Edge"); + + xfer += proto->serializedFieldSize("src", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::Cpp2Ops::serializedSize(proto, &obj->src); + + xfer += proto->serializedFieldSize("dst", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::Cpp2Ops::serializedSize(proto, &obj->dst); + + xfer += proto->serializedFieldSize("type", apache::thrift::protocol::T_I32, 3); + xfer += + detail::pm::protocol_methods::serializedSize( + *proto, obj->type); + + xfer += proto->serializedFieldSize("name", apache::thrift::protocol::T_STRING, 4); + xfer += proto->serializedSizeBinary(obj->name); + + xfer += proto->serializedFieldSize("ranking", apache::thrift::protocol::T_I64, 5); + xfer += detail::pm::protocol_methods::serializedSize(*proto, + obj->ranking); + + xfer += proto->serializedFieldSize("props", apache::thrift::protocol::T_MAP, 6); + xfer += detail::pm::protocol_methods< + type_class::map, + std::unordered_map>::serializedSize(*proto, obj->props); + + xfer += proto->serializedSizeStop(); + return xfer; +} + +template +uint32_t Cpp2Ops::serializedSizeZC(Protocol const* proto, nebula::Edge const* obj) { + uint32_t xfer = 0; + xfer += proto->serializedStructSize("Edge"); + + xfer += proto->serializedFieldSize("src", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::Cpp2Ops::serializedSizeZC(proto, &obj->src); + + xfer += proto->serializedFieldSize("dst", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::Cpp2Ops::serializedSizeZC(proto, &obj->dst); + + xfer += proto->serializedFieldSize("type", apache::thrift::protocol::T_I32, 3); + xfer += + detail::pm::protocol_methods::serializedSize( + *proto, obj->type); + + xfer += proto->serializedFieldSize("name", apache::thrift::protocol::T_STRING, 4); + xfer += proto->serializedSizeZCBinary(obj->name); + + xfer += proto->serializedFieldSize("ranking", apache::thrift::protocol::T_I64, 5); + xfer += detail::pm::protocol_methods::serializedSize(*proto, + obj->ranking); + + xfer += proto->serializedFieldSize("props", apache::thrift::protocol::T_MAP, 6); + xfer += detail::pm::protocol_methods< + type_class::map, + std::unordered_map>::serializedSize(*proto, obj->props); + + xfer += proto->serializedSizeStop(); + return xfer; +} + +} // namespace thrift +} // namespace apache diff --git a/include/common/datatypes/Geography.h b/include/common/datatypes/Geography.h new file mode 100644 index 00000000..eed465c0 --- /dev/null +++ b/include/common/datatypes/Geography.h @@ -0,0 +1,82 @@ +/* Copyright (c) 2020 vesoft inc. All rights reserved. + * + * This source code is licensed under Apache 2.0 License, + * attached with Common Clause Condition 1.0, found in the LICENSES directory. + */ + +#pragma once + +#include "common/datatypes/Value.h" + +// Do not include here, it will indirectly includes a header file which defines a +// enum `BEGIN`(not enum class). While Geography.h is indirectly included by parser.yy, which has a +// macro named `BEGIN`. So they will be conflicted. + +class S2Polygon; + +namespace nebula { + +// clang-format off +/* +static const std::unordered_map kShapeTypeToS2Region = { + // S2PointRegion is a wrapper of S2Point, and it inherits from the S2Region class while S2Point doesn't. + {GeoShape::POINT, S2PointRegion}, + {GeoShape::LINESTRING, S2Polyline}, + {GeoShape::POLYGON, S2Polygon}, +}; +*/ +// clang-format on + +// Do not construct a S2 object when constructing Geography. It's expensive. +// We just construct S2 when doing computation. +struct Geography { + std::string wkb; // TODO(jie) Is it better to store Geometry* or S2Region* here? + + Geography() = default; + + std::string toString() const { + return wkb; + } + + void clear() { + wkb.clear(); + } + + void __clear() { + clear(); + } + + bool operator==(const Geography& rhs) const { + return wkb == rhs.wkb; + } + + bool operator!=(const Geography& rhs) const { + return !(wkb == rhs.wkb); + } + + bool operator<(const Geography& rhs) const { + return wkb < rhs.wkb; + } + +private: + explicit Geography(const std::string& bytes) { + // TODO(jie): Must ensure the bytes is valid + wkb = bytes; + } +}; + +inline std::ostream& operator<<(std::ostream& os, const Geography& g) { + return os << g.wkb; +} + +} // namespace nebula + +namespace std { + +// Inject a customized hash function +template <> +struct hash { + std::size_t operator()(const nebula::Geography& h) const noexcept; +}; + +} // namespace std diff --git a/include/common/datatypes/GeographyOps-inl.h b/include/common/datatypes/GeographyOps-inl.h new file mode 100644 index 00000000..06b7d405 --- /dev/null +++ b/include/common/datatypes/GeographyOps-inl.h @@ -0,0 +1,130 @@ +/* Copyright (c) 2020 vesoft inc. All rights reserved. + * + * This source code is licensed under Apache 2.0 License, + * attached with Common Clause Condition 1.0, found in the LICENSES directory. + */ + +#pragma once + +#include +#include +#include + +#include "common/datatypes/CommonCpp2Ops.h" +#include "common/datatypes/Geography.h" +#include "common/utils/utils.h" + +namespace apache { +namespace thrift { + +/************************************** + * + * Ops for class Geography + * + *************************************/ +namespace detail { + +template <> +struct TccStructTraits { + static void translateFieldName(MAYBE_UNUSED folly::StringPiece _fname, + MAYBE_UNUSED int16_t& fid, + MAYBE_UNUSED apache::thrift::protocol::TType& _ftype) { + if (_fname == "wkb") { + fid = 1; + _ftype = apache::thrift::protocol::T_STRING; + } + } +}; + +} // namespace detail + +inline constexpr protocol::TType Cpp2Ops::thriftType() { + return apache::thrift::protocol::T_STRUCT; +} + +template +uint32_t Cpp2Ops::write(Protocol* proto, nebula::Geography const* obj) { + uint32_t xfer = 0; + xfer += proto->writeStructBegin("Geography"); + xfer += proto->writeFieldBegin("wkb", apache::thrift::protocol::T_STRING, 1); + xfer += proto->writeString(obj->wkb); + xfer += proto->writeFieldEnd(); + xfer += proto->writeFieldStop(); + xfer += proto->writeStructEnd(); + return xfer; +} + +template +void Cpp2Ops::read(Protocol* proto, nebula::Geography* obj) { + apache::thrift::detail::ProtocolReaderStructReadState readState; + + readState.readStructBegin(proto); + + using apache::thrift::TProtocolException; + + if (UNLIKELY(!readState.advanceToNextField(proto, 0, 1, apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_wkb : { proto->readString(obj->wkb); } + + if (UNLIKELY(!readState.advanceToNextField(proto, 1, 0, apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + readState.readStructEnd(proto); + + return; + +_loop: + if (readState.fieldType == apache::thrift::protocol::T_STOP) { + goto _end; + } + + if (proto->kUsesFieldNames()) { + detail::TccStructTraits::translateFieldName( + readState.fieldName(), readState.fieldId, readState.fieldType); + } + + switch (readState.fieldId) { + case 1: { + if (LIKELY(readState.fieldType == apache::thrift::protocol::T_STRING)) { + goto _readField_wkb; + } else { + goto _skip; + } + } + default: { + _skip: + proto->skip(readState.fieldType); + readState.readFieldEnd(proto); + readState.readFieldBeginNoInline(proto); + goto _loop; + } + } +} + +template +uint32_t Cpp2Ops::serializedSize(Protocol const* proto, + nebula::Geography const* obj) { + uint32_t xfer = 0; + xfer += proto->serializedStructSize("Geography"); + xfer += proto->serializedFieldSize("wkb", apache::thrift::protocol::T_STRING, 1); + xfer += proto->serializedSizeString(obj->wkb); + xfer += proto->serializedSizeStop(); + return xfer; +} + +template +uint32_t Cpp2Ops::serializedSizeZC(Protocol const* proto, + nebula::Geography const* obj) { + uint32_t xfer = 0; + xfer += proto->serializedStructSize("Geography"); + xfer += proto->serializedFieldSize("wkb", apache::thrift::protocol::T_STRING, 1); + xfer += proto->serializedSizeString(obj->wkb); + xfer += proto->serializedSizeStop(); + return xfer; +} + +} // namespace thrift +} // namespace apache diff --git a/include/common/datatypes/HostAddr.h b/include/common/datatypes/HostAddr.h new file mode 100644 index 00000000..9fd824fd --- /dev/null +++ b/include/common/datatypes/HostAddr.h @@ -0,0 +1,66 @@ +/* Copyright (c) 2020 vesoft inc. All rights reserved. + * + * This source code is licensed under Apache 2.0 License, + * attached with Common Clause Condition 1.0, found in the LICENSES directory. + */ + +#pragma once + +#include + +#include "common/thrift/ThriftTypes.h" + +namespace nebula { + +// Host address type and utility functions +struct HostAddr { + std::string host; + Port port; + + HostAddr() : host(), port(0) {} + /* + * some one may ctor HostAddr this way : HostAddr host(0, 0) + * C++ will compile this successfully even we don't support an (int, int) ctor + * so, add an explicit delete ctor + * */ + HostAddr(int h, int p) = delete; + HostAddr(std::string h, Port p) : host(std::move(h)), port(p) {} + + void clear() { + host.clear(); + port = 0; + } + + void __clear() { + clear(); + } + + std::string toString() const { + std::stringstream os; + os << "\"" << host << "\"" + << ":" << port; + return os.str(); + } + + bool operator==(const HostAddr& rhs) const; + + bool operator!=(const HostAddr& rhs) const; + + bool operator<(const HostAddr& rhs) const; +}; + +inline std::ostream& operator<<(std::ostream& os, const HostAddr& addr) { + return os << addr.toString(); +} + +} // namespace nebula + +namespace std { + +// Inject a customized hash function +template <> +struct hash { + std::size_t operator()(const nebula::HostAddr& h) const noexcept; +}; + +} // namespace std diff --git a/include/common/datatypes/HostAddrOps-inl.h b/include/common/datatypes/HostAddrOps-inl.h new file mode 100644 index 00000000..d658586e --- /dev/null +++ b/include/common/datatypes/HostAddrOps-inl.h @@ -0,0 +1,163 @@ +/* Copyright (c) 2020 vesoft inc. All rights reserved. + * + * obj source code is licensed under Apache 2.0 License, + * attached with Common Clause Condition 1.0, found in the LICENSES directory. + */ + +#pragma once + +#include +#include +#include + +#include "common/datatypes/CommonCpp2Ops.h" +#include "common/datatypes/HostAddr.h" +#include "common/utils/utils.h" + +namespace apache { +namespace thrift { + +namespace detail { + +template <> +struct TccStructTraits { + static void translateFieldName(MAYBE_UNUSED folly::StringPiece _fname, + MAYBE_UNUSED int16_t& fid, + MAYBE_UNUSED apache::thrift::protocol::TType& _ftype) { + if (_fname == "host") { + fid = 1; + _ftype = apache::thrift::protocol::T_STRING; + } else if (_fname == "port") { + fid = 2; + _ftype = apache::thrift::protocol::T_I32; + } + } +}; + +} // namespace detail + +inline constexpr protocol::TType Cpp2Ops::thriftType() { + return apache::thrift::protocol::T_STRUCT; +} + +template +uint32_t Cpp2Ops::write(Protocol* proto, nebula::HostAddr const* obj) { + uint32_t xfer = 0; + xfer += proto->writeStructBegin("HostAddr"); + + xfer += proto->writeFieldBegin("host", apache::thrift::protocol::T_STRING, 1); + xfer += proto->writeString(obj->host); + xfer += proto->writeFieldEnd(); + + xfer += proto->writeFieldBegin("port", apache::thrift::protocol::T_I32, 2); + xfer += + detail::pm::protocol_methods::write(*proto, obj->port); + xfer += proto->writeFieldEnd(); + + xfer += proto->writeFieldStop(); + xfer += proto->writeStructEnd(); + return xfer; +} + +template +void Cpp2Ops::read(Protocol* proto, nebula::HostAddr* obj) { + detail::ProtocolReaderStructReadState readState; + + readState.readStructBegin(proto); + + using apache::thrift::protocol::TProtocolException; + + if (UNLIKELY(!readState.advanceToNextField(proto, 0, 1, protocol::T_STRING))) { + goto _loop; + } + +_readField_host : { proto->readString(obj->host); } + + if (UNLIKELY(!readState.advanceToNextField(proto, 1, 2, protocol::T_I32))) { + goto _loop; + } + +_readField_port : { + detail::pm::protocol_methods::read(*proto, obj->port); +} + + if (UNLIKELY(!readState.advanceToNextField(proto, 2, 0, protocol::T_STOP))) { + goto _loop; + } + +_end: + readState.readStructEnd(proto); + + return; + +_loop: + if (readState.fieldType == apache::thrift::protocol::T_STOP) { + goto _end; + } + + if (proto->kUsesFieldNames()) { + detail::TccStructTraits::translateFieldName( + readState.fieldName(), readState.fieldId, readState.fieldType); + } + + switch (readState.fieldId) { + case 1: { + if (LIKELY(readState.fieldType == apache::thrift::protocol::T_STRING)) { + goto _readField_host; + } else { + goto _skip; + } + } + case 2: { + if (LIKELY(readState.fieldType == apache::thrift::protocol::T_I32)) { + goto _readField_port; + } else { + goto _skip; + } + } + default: { + _skip: + proto->skip(readState.fieldType); + readState.readFieldEnd(proto); + readState.readFieldBeginNoInline(proto); + goto _loop; + } + } +} + +template +uint32_t Cpp2Ops::serializedSize(Protocol const* proto, + nebula::HostAddr const* obj) { + uint32_t xfer = 0; + xfer += proto->serializedStructSize("HostAddr"); + + xfer += proto->serializedFieldSize("host", apache::thrift::protocol::T_STRING, 1); + xfer += proto->serializedSizeString(obj->host); + + xfer += proto->serializedFieldSize("port", apache::thrift::protocol::T_I32, 2); + xfer += detail::pm::protocol_methods::serializedSize( + *proto, obj->port); + + xfer += proto->serializedSizeStop(); + return xfer; +} + +template +uint32_t Cpp2Ops::serializedSizeZC(Protocol const* proto, + nebula::HostAddr const* obj) { + uint32_t xfer = 0; + xfer += proto->serializedStructSize("HostAddr"); + + xfer += proto->serializedFieldSize("host", apache::thrift::protocol::T_STRING, 1); + xfer += proto->serializedSizeString(obj->host); + + xfer += proto->serializedFieldSize("port", apache::thrift::protocol::T_I32, 2); + xfer += detail::pm::protocol_methods::serializedSize( + *proto, obj->port); + + xfer += proto->serializedSizeStop(); + return xfer; +} + +} // namespace thrift +} // namespace apache diff --git a/include/common/datatypes/KeyValue.h b/include/common/datatypes/KeyValue.h new file mode 100644 index 00000000..47ef987b --- /dev/null +++ b/include/common/datatypes/KeyValue.h @@ -0,0 +1,45 @@ +/* Copyright (c) 2020 vesoft inc. All rights reserved. + * + * This source code is licensed under Apache 2.0 License, + * attached with Common Clause Condition 1.0, found in the LICENSES directory. + */ + +#pragma once + +namespace nebula { + +struct KeyValue { + std::string key; + std::string value; + + KeyValue() {} + KeyValue(KeyValue&& rhs) noexcept : key(std::move(rhs.key)), value(std::move(rhs.value)) {} + KeyValue(const KeyValue& rhs) : key(rhs.key), value(rhs.value) {} + explicit KeyValue(std::pair kv) + : key(std::move(kv.first)), value(std::move(kv.second)) {} + + void clear() { + key.clear(); + value.clear(); + } + + void __clear() { + clear(); + } + + bool operator==(const KeyValue& rhs) const { + if (key != rhs.key) { + return false; + } + return value == rhs.value; + } + + bool operator<(const KeyValue& rhs) const { + if (key != rhs.key) { + return key < rhs.key; + } + return value < rhs.value; + } +}; + +} // namespace nebula diff --git a/include/common/datatypes/KeyValueOps-inl.h b/include/common/datatypes/KeyValueOps-inl.h new file mode 100644 index 00000000..7f77407f --- /dev/null +++ b/include/common/datatypes/KeyValueOps-inl.h @@ -0,0 +1,158 @@ +/* Copyright (c) 2020 vesoft inc. All rights reserved. + * + * This source code is licensed under Apache 2.0 License, + * attached with Common Clause Condition 1.0, found in the LICENSES directory. + */ + +#pragma once + +#include +#include +#include + +#include "common/datatypes/CommonCpp2Ops.h" +#include "common/datatypes/KeyValue.h" +#include "common/utils/utils.h" + +namespace apache { +namespace thrift { + +namespace detail { + +template <> +struct TccStructTraits { + static void translateFieldName(MAYBE_UNUSED folly::StringPiece _fname, + MAYBE_UNUSED int16_t& fid, + MAYBE_UNUSED apache::thrift::protocol::TType& _ftype) { + if (_fname == "key") { + fid = 1; + _ftype = apache::thrift::protocol::T_STRING; + } else if (_fname == "value") { + fid = 2; + _ftype = apache::thrift::protocol::T_STRING; + } + } +}; + +} // namespace detail + +inline constexpr protocol::TType Cpp2Ops::thriftType() { + return apache::thrift::protocol::T_STRUCT; +} + +template +uint32_t Cpp2Ops::write(Protocol* proto, nebula::KeyValue const* obj) { + uint32_t xfer = 0; + xfer += proto->writeStructBegin("KeyValue"); + + xfer += proto->writeFieldBegin("key", apache::thrift::protocol::T_STRING, 1); + xfer += proto->writeBinary(obj->key); + xfer += proto->writeFieldEnd(); + + xfer += proto->writeFieldBegin("value", apache::thrift::protocol::T_STRING, 2); + xfer += proto->writeBinary(obj->value); + xfer += proto->writeFieldEnd(); + + xfer += proto->writeFieldStop(); + xfer += proto->writeStructEnd(); + return xfer; +} + +template +void Cpp2Ops::read(Protocol* proto, nebula::KeyValue* obj) { + detail::ProtocolReaderStructReadState readState; + + readState.readStructBegin(proto); + + using apache::thrift::protocol::TProtocolException; + + if (UNLIKELY(!readState.advanceToNextField(proto, 0, 1, protocol::T_STRING))) { + goto _loop; + } + +_readField_key : { proto->readBinary(obj->key); } + + if (UNLIKELY(!readState.advanceToNextField(proto, 1, 2, protocol::T_STRING))) { + goto _loop; + } + +_readField_value : { proto->readBinary(obj->value); } + + if (UNLIKELY(!readState.advanceToNextField(proto, 2, 0, protocol::T_STOP))) { + goto _loop; + } + +_end: + readState.readStructEnd(proto); + + return; + +_loop: + if (readState.fieldType == apache::thrift::protocol::T_STOP) { + goto _end; + } + + if (proto->kUsesFieldNames()) { + detail::TccStructTraits::translateFieldName( + readState.fieldName(), readState.fieldId, readState.fieldType); + } + + switch (readState.fieldId) { + case 1: { + if (LIKELY(readState.fieldType == apache::thrift::protocol::T_STRING)) { + goto _readField_key; + } else { + goto _skip; + } + } + case 2: { + if (LIKELY(readState.fieldType == apache::thrift::protocol::T_STRING)) { + goto _readField_value; + } else { + goto _skip; + } + } + default: { + _skip: + proto->skip(readState.fieldType); + readState.readFieldEnd(proto); + readState.readFieldBeginNoInline(proto); + goto _loop; + } + } +} + +template +uint32_t Cpp2Ops::serializedSize(Protocol const* proto, + nebula::KeyValue const* obj) { + uint32_t xfer = 0; + xfer += proto->serializedStructSize("KeyValue"); + + xfer += proto->serializedFieldSize("key", apache::thrift::protocol::T_STRING, 1); + xfer += proto->serializedSizeBinary(obj->key); + + xfer += proto->serializedFieldSize("value", apache::thrift::protocol::T_STRING, 2); + xfer += proto->serializedSizeBinary(obj->value); + + xfer += proto->serializedSizeStop(); + return xfer; +} + +template +uint32_t Cpp2Ops::serializedSizeZC(Protocol const* proto, + nebula::KeyValue const* obj) { + uint32_t xfer = 0; + xfer += proto->serializedStructSize("KeyValue"); + + xfer += proto->serializedFieldSize("key", apache::thrift::protocol::T_STRING, 1); + xfer += proto->serializedSizeZCBinary(obj->key); + + xfer += proto->serializedFieldSize("value", apache::thrift::protocol::T_STRING, 2); + xfer += proto->serializedSizeZCBinary(obj->value); + + xfer += proto->serializedSizeStop(); + return xfer; +} + +} // namespace thrift +} // namespace apache diff --git a/include/common/datatypes/List.h b/include/common/datatypes/List.h new file mode 100644 index 00000000..fd215180 --- /dev/null +++ b/include/common/datatypes/List.h @@ -0,0 +1,104 @@ +/* Copyright (c) 2020 vesoft inc. All rights reserved. + * + * This source code is licensed under Apache 2.0 License, + * attached with Common Clause Condition 1.0, found in the LICENSES directory. + */ + +#pragma once + +#include +#include + +#include "common/datatypes/Value.h" + +namespace nebula { + +struct List { + std::vector values; + + List() = default; + List(const List&) = default; + List(List&&) noexcept = default; + explicit List(std::vector&& vals) { + values = std::move(vals); + } + explicit List(const std::vector& l) : values(l) {} + + bool empty() const { + return values.empty(); + } + + void reserve(std::size_t n) { + values.reserve(n); + } + + template ::value>::type> + void emplace_back(T&& v) { + values.emplace_back(std::forward(v)); + } + + void clear() { + values.clear(); + } + + void __clear() { + clear(); + } + + List& operator=(const List& rhs) { + if (this == &rhs) { + return *this; + } + values = rhs.values; + return *this; + } + List& operator=(List&& rhs) noexcept { + if (this == &rhs) { + return *this; + } + values = std::move(rhs.values); + return *this; + } + + bool operator==(const List& rhs) const { + return values == rhs.values; + } + + bool operator<(const List& rhs) const { + return values < rhs.values; + } + + const Value& operator[](size_t i) const { + return values[i]; + } + + bool contains(const Value& value) const { + return std::find(values.begin(), values.end(), value) != values.end(); + } + + size_t size() const { + return values.size(); + } + + std::string toString() const; +}; + +inline std::ostream& operator<<(std::ostream& os, const List& l) { + return os << l.toString(); +} + +} // namespace nebula + +namespace std { +template <> +struct hash { + std::size_t operator()(const nebula::List& h) const noexcept { + size_t seed = 0; + for (auto& v : h.values) { + seed ^= hash()(v) + 0x9e3779b9 + (seed << 6) + (seed >> 2); + } + return seed; + } +}; +} // namespace std diff --git a/include/common/datatypes/ListOps-inl.h b/include/common/datatypes/ListOps-inl.h new file mode 100644 index 00000000..d7a1b7cb --- /dev/null +++ b/include/common/datatypes/ListOps-inl.h @@ -0,0 +1,137 @@ +/* Copyright (c) 2020 vesoft inc. All rights reserved. + * + * This source code is licensed under Apache 2.0 License, + * attached with Common Clause Condition 1.0, found in the LICENSES directory. + */ + +#pragma once + +#include +#include +#include + +#include "common/datatypes/CommonCpp2Ops.h" +#include "common/datatypes/List.h" +#include "common/utils/utils.h" + +namespace apache { +namespace thrift { + +namespace detail { + +template <> +struct TccStructTraits { + static void translateFieldName(MAYBE_UNUSED folly::StringPiece _fname, + MAYBE_UNUSED int16_t& fid, + MAYBE_UNUSED apache::thrift::protocol::TType& _ftype) { + if (_fname == "values") { + fid = 1; + _ftype = apache::thrift::protocol::T_LIST; + } + } +}; + +} // namespace detail + +inline constexpr protocol::TType Cpp2Ops::thriftType() { + return apache::thrift::protocol::T_STRUCT; +} + +template +uint32_t Cpp2Ops::write(Protocol* proto, nebula::List const* obj) { + uint32_t xfer = 0; + xfer += proto->writeStructBegin("NList"); + + xfer += proto->writeFieldBegin("values", apache::thrift::protocol::T_LIST, 1); + xfer += detail::pm::protocol_methods, + std::vector>::write(*proto, obj->values); + xfer += proto->writeFieldEnd(); + + xfer += proto->writeFieldStop(); + xfer += proto->writeStructEnd(); + return xfer; +} + +template +void Cpp2Ops::read(Protocol* proto, nebula::List* obj) { + detail::ProtocolReaderStructReadState readState; + + readState.readStructBegin(proto); + + using apache::thrift::protocol::TProtocolException; + + if (UNLIKELY(!readState.advanceToNextField(proto, 0, 1, protocol::T_LIST))) { + goto _loop; + } + +_readField_values : { + obj->values = std::vector(); + detail::pm::protocol_methods, + std::vector>::read(*proto, obj->values); +} + + if (UNLIKELY(!readState.advanceToNextField(proto, 1, 0, protocol::T_STOP))) { + goto _loop; + } + +_end: + readState.readStructEnd(proto); + + return; + +_loop: + if (readState.fieldType == apache::thrift::protocol::T_STOP) { + goto _end; + } + + if (proto->kUsesFieldNames()) { + detail::TccStructTraits::translateFieldName( + readState.fieldName(), readState.fieldId, readState.fieldType); + } + + switch (readState.fieldId) { + case 1: { + if (LIKELY(readState.fieldType == apache::thrift::protocol::T_LIST)) { + goto _readField_values; + } else { + goto _skip; + } + } + default: { + _skip: + proto->skip(readState.fieldType); + readState.readFieldEnd(proto); + readState.readFieldBeginNoInline(proto); + goto _loop; + } + } +} + +template +uint32_t Cpp2Ops::serializedSize(Protocol const* proto, nebula::List const* obj) { + uint32_t xfer = 0; + xfer += proto->serializedStructSize("NList"); + + xfer += proto->serializedFieldSize("values", apache::thrift::protocol::T_LIST, 1); + xfer += detail::pm::protocol_methods< + type_class::list, + std::vector>::serializedSize(*proto, obj->values); + xfer += proto->serializedSizeStop(); + return xfer; +} + +template +uint32_t Cpp2Ops::serializedSizeZC(Protocol const* proto, nebula::List const* obj) { + uint32_t xfer = 0; + xfer += proto->serializedStructSize("NList"); + + xfer += proto->serializedFieldSize("values", apache::thrift::protocol::T_LIST, 1); + xfer += detail::pm::protocol_methods< + type_class::list, + std::vector>::serializedSize(*proto, obj->values); + xfer += proto->serializedSizeStop(); + return xfer; +} + +} // namespace thrift +} // namespace apache diff --git a/include/common/datatypes/Map.h b/include/common/datatypes/Map.h new file mode 100644 index 00000000..1af7e2ae --- /dev/null +++ b/include/common/datatypes/Map.h @@ -0,0 +1,80 @@ +/* Copyright (c) 2020 vesoft inc. All rights reserved. + * + * This source code is licensed under Apache 2.0 License, + * attached with Common Clause Condition 1.0, found in the LICENSES directory. + */ + +#pragma once + +#include + +#include "common/datatypes/Value.h" + +namespace nebula { + +struct Map { + std::unordered_map kvs; + + Map() = default; + Map(const Map&) = default; + Map(Map&&) noexcept = default; + explicit Map(std::unordered_map values) { + kvs = std::move(values); + } + + Map& operator=(const Map& rhs) { + if (this == &rhs) { + return *this; + } + kvs = rhs.kvs; + return *this; + } + Map& operator=(Map&& rhs) noexcept { + if (this == &rhs) { + return *this; + } + kvs = std::move(rhs.kvs); + return *this; + } + + void clear() { + kvs.clear(); + } + + void __clear() { + clear(); + } + + // the configs of rocksdb will use the interface, so the value need modify to + // string + std::string toString() const; + + bool operator==(const Map& rhs) const { + return kvs == rhs.kvs; + } + + bool contains(const Value& value) const { + if (!value.isStr()) { + return false; + } + return kvs.count(value.getStr()) != 0; + } + + const Value& at(const std::string& key) const { + auto iter = kvs.find(key); + if (iter == kvs.end()) { + return Value::kNullUnknownProp; + } + return iter->second; + } + + size_t size() const { + return kvs.size(); + } +}; + +inline std::ostream& operator<<(std::ostream& os, const Map& m) { + return os << m.toString(); +} + +} // namespace nebula diff --git a/include/common/datatypes/MapOps-inl.h b/include/common/datatypes/MapOps-inl.h new file mode 100644 index 00000000..1cbce03f --- /dev/null +++ b/include/common/datatypes/MapOps-inl.h @@ -0,0 +1,139 @@ +/* Copyright (c) 2020 vesoft inc. All rights reserved. + * + * This source code is licensed under Apache 2.0 License, + * attached with Common Clause Condition 1.0, found in the LICENSES directory. + */ + +#pragma once + +#include +#include +#include + +#include "common/datatypes/CommonCpp2Ops.h" +#include "common/datatypes/Map.h" +#include "common/utils/utils.h" + +namespace apache { +namespace thrift { + +namespace detail { + +template <> +struct TccStructTraits { + static void translateFieldName(MAYBE_UNUSED folly::StringPiece _fname, + MAYBE_UNUSED int16_t& fid, + MAYBE_UNUSED apache::thrift::protocol::TType& _ftype) { + if (_fname == "kvs") { + fid = 1; + _ftype = apache::thrift::protocol::T_MAP; + } + } +}; + +} // namespace detail + +inline constexpr protocol::TType Cpp2Ops::thriftType() { + return apache::thrift::protocol::T_STRUCT; +} + +template +uint32_t Cpp2Ops::write(Protocol* proto, nebula::Map const* obj) { + uint32_t xfer = 0; + xfer += proto->writeStructBegin("NMap"); + + xfer += proto->writeFieldBegin("kvs", apache::thrift::protocol::T_MAP, 1); + xfer += detail::pm::protocol_methods< + type_class::map, + std::unordered_map>::write(*proto, obj->kvs); + xfer += proto->writeFieldEnd(); + + xfer += proto->writeFieldStop(); + xfer += proto->writeStructEnd(); + return xfer; +} + +template +void Cpp2Ops::read(Protocol* proto, nebula::Map* obj) { + detail::ProtocolReaderStructReadState readState; + + readState.readStructBegin(proto); + + using apache::thrift::protocol::TProtocolException; + + if (UNLIKELY(!readState.advanceToNextField(proto, 0, 1, protocol::T_MAP))) { + goto _loop; + } + +_readField_kvs : { + obj->kvs = std::unordered_map(); + detail::pm::protocol_methods, + std::unordered_map>::read(*proto, + obj->kvs); +} + + if (UNLIKELY(!readState.advanceToNextField(proto, 1, 0, protocol::T_STOP))) { + goto _loop; + } + +_end: + readState.readStructEnd(proto); + + return; + +_loop: + if (readState.fieldType == apache::thrift::protocol::T_STOP) { + goto _end; + } + + if (proto->kUsesFieldNames()) { + detail::TccStructTraits::translateFieldName( + readState.fieldName(), readState.fieldId, readState.fieldType); + } + + switch (readState.fieldId) { + case 1: { + if (LIKELY(readState.fieldType == apache::thrift::protocol::T_MAP)) { + goto _readField_kvs; + } else { + goto _skip; + } + } + default: { + _skip: + proto->skip(readState.fieldType); + readState.readFieldEnd(proto); + readState.readFieldBeginNoInline(proto); + goto _loop; + } + } +} + +template +uint32_t Cpp2Ops::serializedSize(Protocol const* proto, nebula::Map const* obj) { + uint32_t xfer = 0; + xfer += proto->serializedStructSize("NMap"); + + xfer += proto->serializedFieldSize("kvs", apache::thrift::protocol::T_MAP, 1); + xfer += detail::pm::protocol_methods< + type_class::map, + std::unordered_map>::serializedSize(*proto, obj->kvs); + xfer += proto->serializedSizeStop(); + return xfer; +} + +template +uint32_t Cpp2Ops::serializedSizeZC(Protocol const* proto, nebula::Map const* obj) { + uint32_t xfer = 0; + xfer += proto->serializedStructSize("NMap"); + + xfer += proto->serializedFieldSize("kvs", apache::thrift::protocol::T_MAP, 1); + xfer += detail::pm::protocol_methods< + type_class::map, + std::unordered_map>::serializedSize(*proto, obj->kvs); + xfer += proto->serializedSizeStop(); + return xfer; +} + +} // namespace thrift +} // namespace apache diff --git a/include/common/datatypes/Path.h b/include/common/datatypes/Path.h new file mode 100644 index 00000000..be976275 --- /dev/null +++ b/include/common/datatypes/Path.h @@ -0,0 +1,204 @@ +/* Copyright (c) 2020 vesoft inc. All rights reserved. + * + * This source code is licensed under Apache 2.0 License, + * attached with Common Clause Condition 1.0, found in the LICENSES directory. + */ + +#pragma once + +#include "common/datatypes/Value.h" +#include "common/datatypes/Vertex.h" +#include "common/thrift/ThriftTypes.h" + +namespace nebula { + +struct Step { + Vertex dst; + EdgeType type; + std::string name; + EdgeRanking ranking; + std::unordered_map props; + + Step() = default; + Step(const Step& s) + : dst(s.dst), type(s.type), name(s.name), ranking(s.ranking), props(s.props) {} + Step(Step&& s) noexcept + : dst(std::move(s.dst)), + type(std::move(s.type)), + name(std::move(s.name)), + ranking(std::move(s.ranking)), + props(std::move(s.props)) {} + Step(Vertex d, + EdgeType t, + std::string n, + EdgeRanking r, + std::unordered_map p) noexcept + : dst(std::move(d)), type(t), name(std::move(n)), ranking(r), props(std::move(p)) {} + + void clear() { + dst.clear(); + type = 0; + name.clear(); + ranking = 0; + props.clear(); + } + + void __clear() { + clear(); + } + + std::string toString() const { + std::stringstream os; + os << "-[" << name << "(" << type << ")]->" + << "(" << dst << ")" + << "@" << ranking << " "; + for (const auto& prop : props) { + os << prop.first << ":" << prop.second << ","; + } + auto path = os.str(); + path.pop_back(); + return path; + } + + Step& operator=(Step&& rhs) noexcept { + if (&rhs != this) { + dst = std::move(rhs.dst); + type = std::move(rhs.type); + name = std::move(rhs.name); + ranking = std::move(rhs.ranking); + props = std::move(rhs.props); + } + return *this; + } + + Step& operator=(const Step& rhs) noexcept { + if (&rhs != this) { + dst = rhs.dst; + type = rhs.type; + name = rhs.name; + ranking = rhs.ranking; + props = rhs.props; + } + return *this; + } + + bool operator==(const Step& rhs) const { + return dst == rhs.dst && type == rhs.type && name == rhs.name && ranking == rhs.ranking && + props == rhs.props; + } + + bool operator<(const Step& rhs) const { + if (dst != rhs.dst) { + return dst < rhs.dst; + } + if (type != rhs.dst) { + return type < rhs.type; + } + if (ranking != rhs.ranking) { + return ranking < rhs.ranking; + } + if (props.size() != rhs.props.size()) { + return props.size() < rhs.props.size(); + } + return false; + } +}; + +struct Path { + Vertex src; + std::vector steps; + + Path() = default; + Path(const Path& p) = default; + Path(Path&& p) noexcept : src(std::move(p.src)), steps(std::move(p.steps)) {} + Path(Vertex v, std::vector s) : src(std::move(v)), steps(std::move(s)) {} + + void clear() { + src.clear(); + steps.clear(); + } + + void __clear() { + clear(); + } + + std::string toString() const { + std::stringstream os; + os << "(" << src << ")"; + os << " "; + for (const auto& s : steps) { + os << s.toString(); + os << " "; + } + return os.str(); + } + + Path& operator=(Path&& rhs) noexcept { + if (&rhs != this) { + src = std::move(rhs.src); + steps = std::move(rhs.steps); + } + return *this; + } + + Path& operator=(const Path& rhs) noexcept { + if (&rhs != this) { + src = rhs.src; + steps = rhs.steps; + } + return *this; + } + + bool operator==(const Path& rhs) const { + return src == rhs.src && steps == rhs.steps; + } + + void addStep(Step step) { + steps.emplace_back(std::move(step)); + } + + void reverse(); + + // Append a path to another one. + // 5->4>3 appended by 3->2->1 => 5->4->3->2->1 + bool append(Path path); + + bool operator<(const Path& rhs) const { + if (src != rhs.src) { + return src < rhs.src; + } + if (steps != rhs.steps) { + return steps < rhs.steps; + } + return false; + } + + bool hasDuplicateEdges() const; + bool hasDuplicateVertices() const; +}; + +inline void swap(Step& a, Step& b) { + auto tmp = std::move(a); + a = std::move(b); + b = std::move(tmp); +} + +inline std::ostream& operator<<(std::ostream& os, const Path& p) { + return os << p.toString(); +} + +} // namespace nebula + +namespace std { + +template <> +struct hash { + std::size_t operator()(const nebula::Step& h) const noexcept; +}; + +template <> +struct hash { + std::size_t operator()(const nebula::Path& h) const noexcept; +}; + +} // namespace std diff --git a/include/common/datatypes/PathOps-inl.h b/include/common/datatypes/PathOps-inl.h new file mode 100644 index 00000000..cb3da52a --- /dev/null +++ b/include/common/datatypes/PathOps-inl.h @@ -0,0 +1,422 @@ +/* Copyright (c) 2020 vesoft inc. All rights reserved. + * + * obj source code is licensed under Apache 2.0 License, + * attached with Common Clause Condition 1.0, found in the LICENSES directory. + */ + +#pragma once + +#include +#include +#include + +#include "common/datatypes/CommonCpp2Ops.h" +#include "common/datatypes/Path.h" +#include "common/utils/utils.h" + +namespace apache { +namespace thrift { + +/************************************** + * + * Ops for class Step + * + *************************************/ +namespace detail { + +template <> +struct TccStructTraits { + static void translateFieldName(MAYBE_UNUSED folly::StringPiece _fname, + MAYBE_UNUSED int16_t& fid, + MAYBE_UNUSED apache::thrift::protocol::TType& _ftype) { + if (_fname == "dst") { + fid = 1; + _ftype = apache::thrift::protocol::T_STRUCT; + } else if (_fname == "type") { + fid = 2; + _ftype = apache::thrift::protocol::T_I32; + } else if (_fname == "name") { + fid = 3; + _ftype = apache::thrift::protocol::T_STRING; + } else if (_fname == "ranking") { + fid = 4; + _ftype = apache::thrift::protocol::T_I64; + } else if (_fname == "props") { + fid = 5; + _ftype = apache::thrift::protocol::T_MAP; + } + } +}; + +} // namespace detail + +inline constexpr protocol::TType Cpp2Ops::thriftType() { + return apache::thrift::protocol::T_STRUCT; +} + +template +uint32_t Cpp2Ops::write(Protocol* proto, nebula::Step const* obj) { + uint32_t xfer = 0; + xfer += proto->writeStructBegin("Step"); + + xfer += proto->writeFieldBegin("dst", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::Cpp2Ops::write(proto, &obj->dst); + xfer += proto->writeFieldEnd(); + + xfer += proto->writeFieldBegin("type", apache::thrift::protocol::T_I32, 2); + // NOTICE: The original id will be transformed to +1/-1, to indicate the edge + // direction. + auto type = obj->type; + if (type != 0) { + type > 0 ? type = 1 : type = -1; + } + xfer += + detail::pm::protocol_methods::write(*proto, type); + xfer += proto->writeFieldEnd(); + + xfer += proto->writeFieldBegin("name", apache::thrift::protocol::T_STRING, 3); + xfer += proto->writeBinary(obj->name); + xfer += proto->writeFieldEnd(); + + xfer += proto->writeFieldBegin("ranking", apache::thrift::protocol::T_I64, 4); + xfer += detail::pm::protocol_methods::write( + *proto, obj->ranking); + xfer += proto->writeFieldEnd(); + + xfer += proto->writeFieldBegin("props", apache::thrift::protocol::T_MAP, 5); + xfer += detail::pm::protocol_methods< + type_class::map, + std::unordered_map>::write(*proto, obj->props); + xfer += proto->writeFieldEnd(); + + xfer += proto->writeFieldStop(); + xfer += proto->writeStructEnd(); + return xfer; +} + +template +void Cpp2Ops::read(Protocol* proto, nebula::Step* obj) { + apache::thrift::detail::ProtocolReaderStructReadState readState; + + readState.readStructBegin(proto); + + using apache::thrift::protocol::TProtocolException; + + if (UNLIKELY(!readState.advanceToNextField(proto, 0, 1, protocol::T_STRUCT))) { + goto _loop; + } + +_readField_dst : { Cpp2Ops::read(proto, &obj->dst); } + + if (UNLIKELY(!readState.advanceToNextField(proto, 1, 2, protocol::T_I32))) { + goto _loop; + } + +_readField_type : { + detail::pm::protocol_methods::read(*proto, obj->type); +} + + if (UNLIKELY(!readState.advanceToNextField(proto, 2, 3, protocol::T_STRING))) { + goto _loop; + } + +_readField_name : { proto->readBinary(obj->name); } + + if (UNLIKELY(!readState.advanceToNextField(proto, 3, 4, protocol::T_I64))) { + goto _loop; + } + +_readField_ranking : { + detail::pm::protocol_methods::read(*proto, + obj->ranking); +} + + if (UNLIKELY(!readState.advanceToNextField(proto, 4, 5, protocol::T_MAP))) { + goto _loop; + } + +_readField_props : { + obj->props = std::unordered_map(); + detail::pm::protocol_methods, + std::unordered_map>::read(*proto, + obj->props); +} + + if (UNLIKELY(!readState.advanceToNextField(proto, 5, 0, protocol::T_STOP))) { + goto _loop; + } + +_end: + readState.readStructEnd(proto); + + return; + +_loop: + if (readState.fieldType == apache::thrift::protocol::T_STOP) { + goto _end; + } + + if (proto->kUsesFieldNames()) { + detail::TccStructTraits::translateFieldName( + readState.fieldName(), readState.fieldId, readState.fieldType); + } + + switch (readState.fieldId) { + case 1: { + if (LIKELY(readState.fieldType == apache::thrift::protocol::T_STRUCT)) { + goto _readField_dst; + } else { + goto _skip; + } + } + case 2: { + if (LIKELY(readState.fieldType == apache::thrift::protocol::T_I32)) { + goto _readField_type; + } else { + goto _skip; + } + } + case 3: { + if (LIKELY(readState.fieldType == apache::thrift::protocol::T_STRING)) { + goto _readField_name; + } else { + goto _skip; + } + } + case 4: { + if (LIKELY(readState.fieldType == apache::thrift::protocol::T_I64)) { + goto _readField_ranking; + } else { + goto _skip; + } + } + case 5: { + if (LIKELY(readState.fieldType == apache::thrift::protocol::T_MAP)) { + goto _readField_props; + } else { + goto _skip; + } + } + default: { + _skip: + proto->skip(readState.fieldType); + readState.readFieldEnd(proto); + readState.readFieldBeginNoInline(proto); + goto _loop; + } + } +} + +template +uint32_t Cpp2Ops::serializedSize(Protocol const* proto, nebula::Step const* obj) { + uint32_t xfer = 0; + xfer += proto->serializedStructSize("Step"); + + xfer += proto->serializedFieldSize("dst", apache::thrift::protocol::T_STRUCT, 1); + xfer += Cpp2Ops::serializedSize(proto, &obj->dst); + + xfer += proto->serializedFieldSize("type", apache::thrift::protocol::T_I32, 2); + xfer += + detail::pm::protocol_methods::serializedSize( + *proto, obj->type); + + xfer += proto->serializedFieldSize("name", apache::thrift::protocol::T_STRING, 3); + xfer += proto->serializedSizeBinary(obj->name); + + xfer += proto->serializedFieldSize("ranking", apache::thrift::protocol::T_I64, 4); + xfer += detail::pm::protocol_methods::serializedSize(*proto, + obj->ranking); + + xfer += proto->serializedFieldSize("props", apache::thrift::protocol::T_MAP, 5); + xfer += detail::pm::protocol_methods< + type_class::map, + std::unordered_map>::serializedSize(*proto, obj->props); + + xfer += proto->serializedSizeStop(); + return xfer; +} + +template +uint32_t Cpp2Ops::serializedSizeZC(Protocol const* proto, nebula::Step const* obj) { + uint32_t xfer = 0; + xfer += proto->serializedStructSize("Step"); + + xfer += proto->serializedFieldSize("dst", apache::thrift::protocol::T_STRUCT, 1); + xfer += Cpp2Ops::serializedSizeZC(proto, &obj->dst); + + xfer += proto->serializedFieldSize("type", apache::thrift::protocol::T_I32, 2); + xfer += + detail::pm::protocol_methods::serializedSize( + *proto, obj->type); + + xfer += proto->serializedFieldSize("name", apache::thrift::protocol::T_STRING, 3); + xfer += proto->serializedSizeZCBinary(obj->name); + + xfer += proto->serializedFieldSize("ranking", apache::thrift::protocol::T_I64, 4); + xfer += detail::pm::protocol_methods::serializedSize(*proto, + obj->ranking); + + xfer += proto->serializedFieldSize("props", apache::thrift::protocol::T_MAP, 5); + xfer += detail::pm::protocol_methods< + type_class::map, + std::unordered_map>::serializedSize(*proto, obj->props); + + xfer += proto->serializedSizeStop(); + return xfer; +} + +/************************************** + * + * Ops for class Path + * + *************************************/ +namespace detail { + +template <> +struct TccStructTraits { + static void translateFieldName(MAYBE_UNUSED folly::StringPiece _fname, + MAYBE_UNUSED int16_t& fid, + MAYBE_UNUSED apache::thrift::protocol::TType& _ftype) { + if (_fname == "src") { + fid = 1; + _ftype = apache::thrift::protocol::T_STRUCT; + } else if (_fname == "steps") { + fid = 2; + _ftype = apache::thrift::protocol::T_LIST; + } + } +}; + +} // namespace detail + +inline constexpr protocol::TType Cpp2Ops::thriftType() { + return apache::thrift::protocol::T_STRUCT; +} + +template +uint32_t Cpp2Ops::write(Protocol* proto, nebula::Path const* obj) { + uint32_t xfer = 0; + xfer += proto->writeStructBegin("Path"); + + xfer += proto->writeFieldBegin("src", apache::thrift::protocol::T_STRUCT, 1); + xfer += Cpp2Ops::write(proto, &obj->src); + xfer += proto->writeFieldEnd(); + + xfer += proto->writeFieldBegin("steps", apache::thrift::protocol::T_LIST, 2); + xfer += detail::pm::protocol_methods, + std::vector>::write(*proto, obj->steps); + xfer += proto->writeFieldEnd(); + + xfer += proto->writeFieldStop(); + xfer += proto->writeStructEnd(); + return xfer; +} + +template +void Cpp2Ops::read(Protocol* proto, nebula::Path* obj) { + detail::ProtocolReaderStructReadState readState; + + readState.readStructBegin(proto); + + using apache::thrift::protocol::TProtocolException; + + if (UNLIKELY(!readState.advanceToNextField(proto, 0, 1, protocol::T_STRUCT))) { + goto _loop; + } + +_readField_src : { Cpp2Ops::read(proto, &obj->src); } + + if (UNLIKELY(!readState.advanceToNextField(proto, 1, 2, protocol::T_LIST))) { + goto _loop; + } + +_readField_steps : { + obj->steps = std::vector(); + detail::pm::protocol_methods, + std::vector>::read(*proto, obj->steps); +} + + if (UNLIKELY(!readState.advanceToNextField(proto, 2, 0, protocol::T_STOP))) { + goto _loop; + } + +_end: + readState.readStructEnd(proto); + + return; + +_loop: + if (readState.fieldType == apache::thrift::protocol::T_STOP) { + goto _end; + } + + if (proto->kUsesFieldNames()) { + detail::TccStructTraits::translateFieldName( + readState.fieldName(), readState.fieldId, readState.fieldType); + } + + switch (readState.fieldId) { + case 1: { + if (LIKELY(readState.fieldType == apache::thrift::protocol::T_STRUCT)) { + goto _readField_src; + } else { + goto _skip; + } + } + case 2: { + if (LIKELY(readState.fieldType == apache::thrift::protocol::T_LIST)) { + goto _readField_steps; + } else { + goto _skip; + } + } + default: { + _skip: + proto->skip(readState.fieldType); + readState.readFieldEnd(proto); + readState.readFieldBeginNoInline(proto); + goto _loop; + } + } +} + +template +uint32_t Cpp2Ops::serializedSize(Protocol const* proto, nebula::Path const* obj) { + uint32_t xfer = 0; + xfer += proto->serializedStructSize("Path"); + + xfer += proto->serializedFieldSize("src", apache::thrift::protocol::T_STRUCT, 1); + xfer += Cpp2Ops::serializedSize(proto, &obj->src); + + xfer += proto->serializedFieldSize("steps", apache::thrift::protocol::T_LIST, 2); + xfer += + detail::pm::protocol_methods, + std::vector>::serializedSize(*proto, + obj->steps); + + xfer += proto->serializedSizeStop(); + return xfer; +} + +template +uint32_t Cpp2Ops::serializedSizeZC(Protocol const* proto, nebula::Path const* obj) { + uint32_t xfer = 0; + xfer += proto->serializedStructSize("Path"); + + xfer += proto->serializedFieldSize("src", apache::thrift::protocol::T_STRUCT, 1); + xfer += Cpp2Ops::serializedSizeZC(proto, &obj->src); + + xfer += proto->serializedFieldSize("steps", apache::thrift::protocol::T_LIST, 2); + xfer += + detail::pm::protocol_methods, + std::vector>::serializedSize(*proto, + obj->steps); + + xfer += proto->serializedSizeStop(); + return xfer; +} + +} // namespace thrift +} // namespace apache diff --git a/include/common/datatypes/Set.h b/include/common/datatypes/Set.h new file mode 100644 index 00000000..712e287e --- /dev/null +++ b/include/common/datatypes/Set.h @@ -0,0 +1,68 @@ +/* Copyright (c) 2020 vesoft inc. All rights reserved. + * + * This source code is licensed under Apache 2.0 License, + * attached with Common Clause Condition 1.0, found in the LICENSES directory. + */ + +#pragma once + +#include + +#include "common/datatypes/Value.h" + +namespace nebula { + +struct Set { + std::unordered_set values; + + Set() = default; + Set(const Set&) = default; + Set(Set&&) noexcept = default; + explicit Set(std::unordered_set value) { + values = std::move(value); + } + + void clear() { + values.clear(); + } + + void __clear() { + clear(); + } + + std::string toString() const; + + Set& operator=(const Set& rhs) { + if (this == &rhs) { + return *this; + } + values = rhs.values; + return *this; + } + + Set& operator=(Set&& rhs) noexcept { + if (this == &rhs) { + return *this; + } + values = std::move(rhs.values); + return *this; + } + + bool operator==(const Set& rhs) const { + return values == rhs.values; + } + + bool contains(const Value& value) const { + return values.count(value) != 0; + } + + size_t size() const { + return values.size(); + } +}; + +inline std::ostream& operator<<(std::ostream& os, const Set& s) { + return os << s.toString(); +} + +} // namespace nebula diff --git a/include/common/datatypes/SetOps-inl.h b/include/common/datatypes/SetOps-inl.h new file mode 100644 index 00000000..87787fea --- /dev/null +++ b/include/common/datatypes/SetOps-inl.h @@ -0,0 +1,136 @@ +/* Copyright (c) 2020 vesoft inc. All rights reserved. + * + * This source code is licensed under Apache 2.0 License, + * attached with Common Clause Condition 1.0, found in the LICENSES directory. + */ + +#pragma once + +#include +#include +#include + +#include "common/datatypes/CommonCpp2Ops.h" +#include "common/datatypes/Set.h" +#include "common/utils/utils.h" + +namespace apache { +namespace thrift { + +namespace detail { + +template <> +struct TccStructTraits { + static void translateFieldName(MAYBE_UNUSED folly::StringPiece _fname, + MAYBE_UNUSED int16_t& fid, + MAYBE_UNUSED apache::thrift::protocol::TType& _ftype) { + if (_fname == "values") { + fid = 1; + _ftype = apache::thrift::protocol::T_STRUCT; + } + } +}; + +} // namespace detail + +inline constexpr protocol::TType Cpp2Ops::thriftType() { + return apache::thrift::protocol::T_STRUCT; +} + +template +uint32_t Cpp2Ops::write(Protocol* proto, nebula::Set const* obj) { + uint32_t xfer = 0; + xfer += proto->writeStructBegin("NSet"); + + xfer += proto->writeFieldBegin("values", apache::thrift::protocol::T_SET, 1); + xfer += + detail::pm::protocol_methods, + std::unordered_set>::write(*proto, obj->values); + xfer += proto->writeFieldEnd(); + + xfer += proto->writeFieldStop(); + xfer += proto->writeStructEnd(); + return xfer; +} + +template +void Cpp2Ops::read(Protocol* proto, nebula::Set* obj) { + detail::ProtocolReaderStructReadState readState; + + readState.readStructBegin(proto); + + using apache::thrift::protocol::TProtocolException; + + if (UNLIKELY(!readState.advanceToNextField(proto, 0, 1, protocol::T_SET))) { + goto _loop; + } + +_readField_values : { + obj->values = std::unordered_set(); + detail::pm::protocol_methods, + std::unordered_set>::read(*proto, obj->values); +} + + if (UNLIKELY(!readState.advanceToNextField(proto, 1, 0, protocol::T_STOP))) { + goto _loop; + } + +_end: + readState.readStructEnd(proto); + + return; + +_loop: + if (readState.fieldType == apache::thrift::protocol::T_STOP) { + goto _end; + } + + if (proto->kUsesFieldNames()) { + detail::TccStructTraits::translateFieldName( + readState.fieldName(), readState.fieldId, readState.fieldType); + } + + switch (readState.fieldId) { + case 1: { + if (LIKELY(readState.fieldType == apache::thrift::protocol::T_SET)) { + goto _readField_values; + } else { + goto _skip; + } + } + default: { + _skip: + proto->skip(readState.fieldType); + readState.readFieldEnd(proto); + readState.readFieldBeginNoInline(proto); + goto _loop; + } + } +} + +template +uint32_t Cpp2Ops::serializedSize(Protocol const* proto, nebula::Set const* obj) { + uint32_t xfer = 0; + xfer += proto->serializedStructSize("NSet"); + xfer += proto->serializedFieldSize("values", apache::thrift::protocol::T_SET, 1); + xfer += detail::pm::protocol_methods< + type_class::set, + std::unordered_set>::serializedSize(*proto, obj->values); + xfer += proto->serializedSizeStop(); + return xfer; +} + +template +uint32_t Cpp2Ops::serializedSizeZC(Protocol const* proto, nebula::Set const* obj) { + uint32_t xfer = 0; + xfer += proto->serializedStructSize("NSet"); + xfer += proto->serializedFieldSize("values", apache::thrift::protocol::T_SET, 1); + xfer += detail::pm::protocol_methods< + type_class::set, + std::unordered_set>::serializedSize(*proto, obj->values); + xfer += proto->serializedSizeStop(); + return xfer; +} + +} // namespace thrift +} // namespace apache diff --git a/include/common/datatypes/Value.h b/include/common/datatypes/Value.h new file mode 100644 index 00000000..90019269 --- /dev/null +++ b/include/common/datatypes/Value.h @@ -0,0 +1,515 @@ +/* Copyright (c) 2020 vesoft inc. All rights reserved. + * + * This source code is licensed under Apache 2.0 License, + * attached with Common Clause Condition 1.0, found in the LICENSES directory. + */ + +#pragma once + +#include + +#include "common/datatypes/Date.h" +#include "common/thrift/ThriftTypes.h" + +namespace apache { +namespace thrift { + +template +class Cpp2Ops; + +} // namespace thrift +} // namespace apache + +namespace nebula { + +struct Vertex; +struct Edge; +struct Path; +struct Map; +struct List; +struct Set; +struct DataSet; +struct Geography; + +enum class NullType { + __NULL__ = 0, + NaN = 1, + BAD_DATA = 2, + BAD_TYPE = 3, + ERR_OVERFLOW = 4, + UNKNOWN_PROP = 5, + DIV_BY_ZERO = 6, + OUT_OF_RANGE = 7, +}; + +struct Value { + static const Value kEmpty; + static const Value kNullValue; + static const Value kNullNaN; + static const Value kNullBadData; + static const Value kNullBadType; + static const Value kNullOverflow; + static const Value kNullUnknownProp; + static const Value kNullDivByZero; + static const Value kNullOutOfRange; + + static const uint64_t kEmptyNullType; + static const uint64_t kNumericType; + + friend class apache::thrift::Cpp2Ops; + + enum class Type : uint64_t { + __EMPTY__ = 1UL, + BOOL = 1UL << 1, + INT = 1UL << 2, + FLOAT = 1UL << 3, + STRING = 1UL << 4, + DATE = 1UL << 5, + TIME = 1UL << 6, + DATETIME = 1UL << 7, + VERTEX = 1UL << 8, + EDGE = 1UL << 9, + PATH = 1UL << 10, + LIST = 1UL << 11, + MAP = 1UL << 12, + SET = 1UL << 13, + DATASET = 1UL << 14, + GEOGRAPHY = 1UL << 15, + NULLVALUE = 1UL << 63, + }; + + // Constructors + Value() : type_(Type::__EMPTY__) {} + Value(Value&& rhs) noexcept; + Value(const Value& rhs); + + // For the cpp bool-pointer conversion, if Value ctor accept a pointer without + // matched ctor it will convert to bool type and the match the bool value + // ctor, So we disable all pointer ctor except the char* + template + Value(T*) = delete; // NOLINT + Value(const std::nullptr_t) = delete; // NOLINT + Value(const NullType& v); // NOLINT + Value(NullType&& v); // NOLINT + Value(const bool& v); // NOLINT + Value(bool&& v); // NOLINT + Value(const int8_t& v); // NOLINT + Value(int8_t&& v); // NOLINT + Value(const int16_t& v); // NOLINT + Value(int16_t&& v); // NOLINT + Value(const int32_t& v); // NOLINT + Value(int32_t&& v); // NOLINT + Value(const int64_t& v); // NOLINT + Value(int64_t&& v); // NOLINT + Value(const double& v); // NOLINT + Value(double&& v); // NOLINT + Value(const std::string& v); // NOLINT + Value(std::string&& v); // NOLINT + Value(const char* v); // NOLINT + Value(const Date& v); // NOLINT + Value(Date&& v); // NOLINT + Value(const Time& v); // NOLINT + Value(Time&& v); // NOLINT + Value(const DateTime& v); // NOLINT + Value(DateTime&& v); // NOLINT + Value(const Vertex& v); // NOLINT + Value(Vertex&& v); // NOLINT + Value(const Edge& v); // NOLINT + Value(Edge&& v); // NOLINT + Value(const Path& v); // NOLINT + Value(Path&& v); // NOLINT + Value(const List& v); // NOLINT + Value(List&& v); // NOLINT + Value(const Map& v); // NOLINT + Value(Map&& v); // NOLINT + Value(const Set& v); // NOLINT + Value(Set&& v); // NOLINT + Value(const DataSet& v); // NOLINT + Value(DataSet&& v); // NOLINT + Value(const Geography& v); // NOLINT + Value(Geography&& v); // NOLINT + ~Value() { + clear(); + } + + Type type() const noexcept { + return type_; + } + + const std::string& typeName() const; + + bool empty() const { + return type_ == Type::__EMPTY__; + } + bool isNull() const { + return type_ == Type::NULLVALUE; + } + bool isBadNull() const { + if (!isNull()) { + return false; + } + auto& null = value_.nVal; + return null == NullType::NaN || null == NullType::BAD_DATA || null == NullType::BAD_TYPE || + null == NullType::ERR_OVERFLOW || null == NullType::UNKNOWN_PROP || + null == NullType::DIV_BY_ZERO || null == NullType::OUT_OF_RANGE; + } + bool isNumeric() const { + return type_ == Type::INT || type_ == Type::FLOAT; + } + bool isBool() const { + return type_ == Type::BOOL; + } + bool isInt() const { + return type_ == Type::INT; + } + bool isFloat() const { + return type_ == Type::FLOAT; + } + bool isStr() const { + return type_ == Type::STRING; + } + bool isDate() const { + return type_ == Type::DATE; + } + bool isTime() const { + return type_ == Type::TIME; + } + bool isDateTime() const { + return type_ == Type::DATETIME; + } + bool isVertex() const { + return type_ == Type::VERTEX; + } + bool isEdge() const { + return type_ == Type::EDGE; + } + bool isPath() const { + return type_ == Type::PATH; + } + bool isList() const { + return type_ == Type::LIST; + } + bool isMap() const { + return type_ == Type::MAP; + } + bool isSet() const { + return type_ == Type::SET; + } + bool isDataSet() const { + return type_ == Type::DATASET; + } + bool isGeography() const { + return type_ == Type::GEOGRAPHY; + } + + void clear(); + + void __clear() { + clear(); + } + + Value& operator=(Value&& rhs) noexcept; + Value& operator=(const Value& rhs); + + void setNull(const NullType& v); + void setNull(NullType&& v); + void setBool(const bool& v); + void setBool(bool&& v); + void setInt(const int8_t& v); + void setInt(int8_t&& v); + void setInt(const int16_t& v); + void setInt(int16_t&& v); + void setInt(const int32_t& v); + void setInt(int32_t&& v); + void setInt(const int64_t& v); + void setInt(int64_t&& v); + void setFloat(const double& v); + void setFloat(double&& v); + void setStr(const std::string& v); + void setStr(std::string&& v); + void setStr(const char* v); + void setDate(const Date& v); + void setDate(Date&& v); + void setTime(const Time& v); + void setTime(Time&& v); + void setDateTime(const DateTime& v); + void setDateTime(DateTime&& v); + void setVertex(const Vertex& v); + void setVertex(Vertex&& v); + void setVertex(std::unique_ptr&& v); + void setEdge(const Edge& v); + void setEdge(Edge&& v); + void setEdge(std::unique_ptr&& v); + void setPath(const Path& v); + void setPath(Path&& v); + void setPath(std::unique_ptr&& v); + void setList(const List& v); + void setList(List&& v); + void setList(std::unique_ptr&& v); + void setMap(const Map& v); + void setMap(Map&& v); + void setMap(std::unique_ptr&& v); + void setSet(const Set& v); + void setSet(Set&& v); + void setSet(std::unique_ptr&& v); + void setDataSet(const DataSet& v); + void setDataSet(DataSet&& v); + void setDataSet(std::unique_ptr&& v); + void setGeography(const Geography& v); + void setGeography(Geography&& v); + void setGeography(std::unique_ptr&& v); + + const NullType& getNull() const; + const bool& getBool() const; + const int64_t& getInt() const; + const double& getFloat() const; + const std::string& getStr() const; + const Date& getDate() const; + const Time& getTime() const; + const DateTime& getDateTime() const; + const Vertex& getVertex() const; + const Vertex* getVertexPtr() const; + const Edge& getEdge() const; + const Edge* getEdgePtr() const; + const Path& getPath() const; + const Path* getPathPtr() const; + const List& getList() const; + const List* getListPtr() const; + const Map& getMap() const; + const Map* getMapPtr() const; + const Set& getSet() const; + const Set* getSetPtr() const; + const DataSet& getDataSet() const; + const DataSet* getDataSetPtr() const; + const Geography& getGeography() const; + const Geography* getGeographyPtr() const; + + NullType moveNull(); + bool moveBool(); + int64_t moveInt(); + double moveFloat(); + std::string moveStr(); + Date moveDate(); + Time moveTime(); + DateTime moveDateTime(); + Vertex moveVertex(); + Edge moveEdge(); + Path movePath(); + List moveList(); + Map moveMap(); + Set moveSet(); + DataSet moveDataSet(); + Geography moveGeography(); + + NullType& mutableNull(); + bool& mutableBool(); + int64_t& mutableInt(); + double& mutableFloat(); + std::string& mutableStr(); + Date& mutableDate(); + Time& mutableTime(); + DateTime& mutableDateTime(); + Vertex& mutableVertex(); + Edge& mutableEdge(); + Path& mutablePath(); + List& mutableList(); + Map& mutableMap(); + Set& mutableSet(); + DataSet& mutableDataSet(); + Geography& mutableGeography(); + + static const Value& null() noexcept { + return kNullValue; + } + + std::string toString() const; + + Value toBool() const; + Value toFloat() const; + Value toInt() const; + + Value lessThan(const Value& v) const; + + Value equal(const Value& v) const; + +private: + Type type_; + + union Storage { + NullType nVal; + bool bVal; + int64_t iVal; + double fVal; + std::unique_ptr sVal; + Date dVal; + Time tVal; + DateTime dtVal; + std::unique_ptr vVal; + std::unique_ptr eVal; + std::unique_ptr pVal; + std::unique_ptr lVal; + std::unique_ptr mVal; + std::unique_ptr uVal; + std::unique_ptr gVal; + std::unique_ptr ggVal; + + Storage() {} + ~Storage() {} + } value_; + + template + void destruct(T& val) { + (&val)->~T(); + } + + // Null value + void setN(const NullType& v); + void setN(NullType&& v); + // Bool value + void setB(const bool& v); + void setB(bool&& v); + // Integer value + void setI(const int64_t& v); + void setI(int64_t&& v); + // Double float value + void setF(const double& v); + void setF(double&& v); + // String value + void setS(const std::string& v); + void setS(std::string&& v); + void setS(const char* v); + void setS(std::unique_ptr v); + // Date value + void setD(const Date& v); + void setD(Date&& v); + // Date value + void setT(const Time& v); + void setT(Time&& v); + // DateTime value + void setDT(const DateTime& v); + void setDT(DateTime&& v); + // Vertex value + void setV(const std::unique_ptr& v); + void setV(std::unique_ptr&& v); + void setV(const Vertex& v); + void setV(Vertex&& v); + // Edge value + void setE(const std::unique_ptr& v); + void setE(std::unique_ptr&& v); + void setE(const Edge& v); + void setE(Edge&& v); + // Path value + void setP(const std::unique_ptr& v); + void setP(std::unique_ptr&& v); + void setP(const Path& v); + void setP(Path&& v); + // List value + void setL(const std::unique_ptr& v); + void setL(std::unique_ptr&& v); + void setL(const List& v); + void setL(List&& v); + // Map value + void setM(const std::unique_ptr& v); + void setM(std::unique_ptr&& v); + void setM(const Map& v); + void setM(Map&& v); + // Set value + void setU(const std::unique_ptr& v); + void setU(std::unique_ptr&& v); + void setU(const Set& v); + void setU(Set&& v); + // DataSet value + void setG(const std::unique_ptr& v); + void setG(std::unique_ptr&& v); + void setG(const DataSet& v); + void setG(DataSet&& v); + // Geography value + void setGG(const std::unique_ptr& v); + void setGG(std::unique_ptr&& v); + void setGG(const Geography& v); + void setGG(Geography&& v); +}; + +static_assert(sizeof(Value) == 16UL, "The size of Value should be 16UL"); + +void swap(Value& a, Value& b); + +constexpr auto kEpsilon = 1e-8; + +// Arithmetic operations +Value operator+(const Value& lhs, const Value& rhs); +Value operator-(const Value& lhs, const Value& rhs); +Value operator*(const Value& lhs, const Value& rhs); +Value operator/(const Value& lhs, const Value& rhs); +Value operator%(const Value& lhs, const Value& rhs); +// Unary operations +Value operator-(const Value& rhs); +Value operator!(const Value& rhs); +// Comparison operations +// 1. we compare the type directly in these cases: +// if type do not match except both numeric +// if lhs and rhs have at least one null or empty +// 2. null is the biggest, empty is the smallest +bool operator<(const Value& lhs, const Value& rhs); +bool operator==(const Value& lhs, const Value& rhs); +bool operator!=(const Value& lhs, const Value& rhs); +bool operator>(const Value& lhs, const Value& rhs); +bool operator<=(const Value& lhs, const Value& rhs); +bool operator>=(const Value& lhs, const Value& rhs); +// Logical operations +Value operator&&(const Value& lhs, const Value& rhs); +Value operator||(const Value& lhs, const Value& rhs); +// Bit operations +Value operator&(const Value& lhs, const Value& rhs); +Value operator|(const Value& lhs, const Value& rhs); +Value operator^(const Value& lhs, const Value& rhs); +// Visualize +std::ostream& operator<<(std::ostream& os, const Value::Type& type); +inline std::ostream& operator<<(std::ostream& os, const Value& value) { + return os << value.toString(); +} + +inline uint64_t operator|(const Value::Type& lhs, const Value::Type& rhs) { + return static_cast(lhs) | static_cast(rhs); +} +inline uint64_t operator|(const uint64_t lhs, const Value::Type& rhs) { + return lhs | static_cast(rhs); +} +inline uint64_t operator|(const Value::Type& lhs, const uint64_t rhs) { + return static_cast(lhs) | rhs; +} +inline uint64_t operator&(const Value::Type& lhs, const Value::Type& rhs) { + return static_cast(lhs) & static_cast(rhs); +} +inline uint64_t operator&(const uint64_t lhs, const Value::Type& rhs) { + return lhs & static_cast(rhs); +} +inline uint64_t operator&(const Value::Type& lhs, const uint64_t rhs) { + return static_cast(lhs) & rhs; +} + +} // namespace nebula + +namespace std { + +// Inject a customized hash function +template <> +struct hash { + std::size_t operator()(const nebula::Value& h) const noexcept; +}; + +template <> +struct hash { + std::size_t operator()(const nebula::Value* h) const noexcept { + return h == nullptr ? 0 : hash()(*h); + } +}; + +template <> +struct equal_to { + bool operator()(const nebula::Value* lhs, const nebula::Value* rhs) const noexcept { + return lhs == rhs ? true : (lhs != nullptr) && (rhs != nullptr) && (*lhs == *rhs); + } +}; + +} // namespace std diff --git a/include/common/datatypes/ValueOps-inl.h b/include/common/datatypes/ValueOps-inl.h new file mode 100644 index 00000000..f20f9763 --- /dev/null +++ b/include/common/datatypes/ValueOps-inl.h @@ -0,0 +1,730 @@ +/* Copyright (c) 2020 vesoft inc. All rights reserved. + * + * obj source code is licensed under Apache 2.0 License, + * attached with Common Clause Condition 1.0, found in the LICENSES directory. + */ + +#pragma once + +#include +#include +#include +#include + +#include "common/datatypes/CommonCpp2Ops.h" +#include "common/datatypes/DataSetOps-inl.h" +#include "common/datatypes/DateOps-inl.h" +#include "common/datatypes/EdgeOps-inl.h" +#include "common/datatypes/GeographyOps-inl.h" +#include "common/datatypes/ListOps-inl.h" +#include "common/datatypes/MapOps-inl.h" +#include "common/datatypes/PathOps-inl.h" +#include "common/datatypes/SetOps-inl.h" +#include "common/datatypes/Value.h" +#include "common/datatypes/VertexOps-inl.h" +#include "common/utils/utils.h" + +namespace apache { +namespace thrift { + +namespace detail { + +template <> +struct TccStructTraits { + static void translateFieldName(MAYBE_UNUSED folly::StringPiece _fname, + MAYBE_UNUSED int16_t& fid, + MAYBE_UNUSED apache::thrift::protocol::TType& _ftype) { + if (_fname == "nVal") { + fid = 1; + _ftype = apache::thrift::protocol::T_I32; + } else if (_fname == "bVal") { + fid = 2; + _ftype = apache::thrift::protocol::T_BOOL; + } else if (_fname == "iVal") { + fid = 3; + _ftype = apache::thrift::protocol::T_I64; + } else if (_fname == "fVal") { + fid = 4; + _ftype = apache::thrift::protocol::T_DOUBLE; + } else if (_fname == "sVal") { + fid = 5; + _ftype = apache::thrift::protocol::T_STRING; + } else if (_fname == "dVal") { + fid = 6; + _ftype = apache::thrift::protocol::T_STRUCT; + } else if (_fname == "tVal") { + fid = 7; + _ftype = apache::thrift::protocol::T_STRUCT; + } else if (_fname == "dtVal") { + fid = 8; + _ftype = apache::thrift::protocol::T_STRUCT; + } else if (_fname == "vVal") { + fid = 9; + _ftype = apache::thrift::protocol::T_STRUCT; + } else if (_fname == "eVal") { + fid = 10; + _ftype = apache::thrift::protocol::T_STRUCT; + } else if (_fname == "pVal") { + fid = 11; + _ftype = apache::thrift::protocol::T_STRUCT; + } else if (_fname == "lVal") { + fid = 12; + _ftype = apache::thrift::protocol::T_STRUCT; + } else if (_fname == "mVal") { + fid = 13; + _ftype = apache::thrift::protocol::T_STRUCT; + } else if (_fname == "uVal") { + fid = 14; + _ftype = apache::thrift::protocol::T_STRUCT; + } else if (_fname == "gVal") { + fid = 15; + _ftype = apache::thrift::protocol::T_STRUCT; + } else if (_fname == "ggVal") { + fid = 16; + _ftype = apache::thrift::protocol::T_STRUCT; + } + } +}; + +} // namespace detail + +inline constexpr apache::thrift::protocol::TType Cpp2Ops::thriftType() { + return apache::thrift::protocol::T_STRUCT; +} + +template +uint32_t Cpp2Ops::write(Protocol* proto, nebula::Value const* obj) { + uint32_t xfer = 0; + xfer += proto->writeStructBegin("Value"); + + switch (obj->type()) { + case nebula::Value::Type::NULLVALUE: { + xfer += proto->writeFieldBegin("nVal", protocol::T_I32, 1); + xfer += detail::pm::protocol_methods::write( + *proto, obj->getNull()); + xfer += proto->writeFieldEnd(); + break; + } + case nebula::Value::Type::BOOL: { + xfer += proto->writeFieldBegin("bVal", protocol::T_BOOL, 2); + xfer += proto->writeBool(obj->getBool()); + xfer += proto->writeFieldEnd(); + break; + } + case nebula::Value::Type::INT: { + xfer += proto->writeFieldBegin("iVal", protocol::T_I64, 3); + xfer += detail::pm::protocol_methods::write( + *proto, obj->getInt()); + xfer += proto->writeFieldEnd(); + break; + } + case nebula::Value::Type::FLOAT: { + xfer += proto->writeFieldBegin("fVal", protocol::T_DOUBLE, 4); + xfer += proto->writeDouble(obj->getFloat()); + xfer += proto->writeFieldEnd(); + break; + } + case nebula::Value::Type::STRING: { + xfer += proto->writeFieldBegin("sVal", protocol::T_STRING, 5); + xfer += proto->writeBinary(obj->getStr()); + xfer += proto->writeFieldEnd(); + break; + } + case nebula::Value::Type::DATE: { + xfer += proto->writeFieldBegin("dVal", protocol::T_STRUCT, 6); + xfer += Cpp2Ops::write(proto, &obj->getDate()); + xfer += proto->writeFieldEnd(); + break; + } + case nebula::Value::Type::TIME: { + xfer += proto->writeFieldBegin("tVal", protocol::T_STRUCT, 7); + xfer += Cpp2Ops::write(proto, &obj->getTime()); + xfer += proto->writeFieldEnd(); + break; + } + case nebula::Value::Type::DATETIME: { + xfer += proto->writeFieldBegin("dtVal", protocol::T_STRUCT, 8); + xfer += Cpp2Ops::write(proto, &obj->getDateTime()); + xfer += proto->writeFieldEnd(); + break; + } + case nebula::Value::Type::VERTEX: { + xfer += proto->writeFieldBegin("vVal", protocol::T_STRUCT, 9); + if (obj->getVertexPtr()) { + xfer += Cpp2Ops::write(proto, obj->getVertexPtr()); + } else { + xfer += proto->writeStructBegin("Vertex"); + xfer += proto->writeStructEnd(); + xfer += proto->writeFieldStop(); + } + xfer += proto->writeFieldEnd(); + break; + } + case nebula::Value::Type::EDGE: { + xfer += proto->writeFieldBegin("eVal", protocol::T_STRUCT, 10); + if (obj->getEdgePtr()) { + xfer += Cpp2Ops::write(proto, obj->getEdgePtr()); + } else { + xfer += proto->writeStructBegin("Edge"); + xfer += proto->writeStructEnd(); + xfer += proto->writeFieldStop(); + } + xfer += proto->writeFieldEnd(); + break; + } + case nebula::Value::Type::PATH: { + xfer += proto->writeFieldBegin("pVal", protocol::T_STRUCT, 11); + if (obj->getPathPtr()) { + xfer += Cpp2Ops::write(proto, obj->getPathPtr()); + } else { + xfer += proto->writeStructBegin("Path"); + xfer += proto->writeStructEnd(); + xfer += proto->writeFieldStop(); + } + xfer += proto->writeFieldEnd(); + break; + } + case nebula::Value::Type::LIST: { + xfer += proto->writeFieldBegin("lVal", protocol::T_STRUCT, 12); + if (obj->getListPtr()) { + xfer += Cpp2Ops::write(proto, obj->getListPtr()); + } else { + xfer += proto->writeStructBegin("NList"); + xfer += proto->writeStructEnd(); + xfer += proto->writeFieldStop(); + } + xfer += proto->writeFieldEnd(); + break; + } + case nebula::Value::Type::MAP: { + xfer += proto->writeFieldBegin("mVal", protocol::T_STRUCT, 13); + if (obj->getMapPtr()) { + xfer += Cpp2Ops::write(proto, obj->getMapPtr()); + } else { + xfer += proto->writeStructBegin("NMap"); + xfer += proto->writeStructEnd(); + xfer += proto->writeFieldStop(); + } + xfer += proto->writeFieldEnd(); + break; + } + case nebula::Value::Type::SET: { + xfer += proto->writeFieldBegin("uVal", protocol::T_STRUCT, 14); + if (obj->getSetPtr()) { + xfer += Cpp2Ops::write(proto, obj->getSetPtr()); + } else { + xfer += proto->writeStructBegin("NSet"); + xfer += proto->writeStructEnd(); + xfer += proto->writeFieldStop(); + } + xfer += proto->writeFieldEnd(); + break; + } + case nebula::Value::Type::DATASET: { + xfer += proto->writeFieldBegin("gVal", protocol::T_STRUCT, 15); + if (obj->getDataSetPtr()) { + xfer += Cpp2Ops::write(proto, obj->getDataSetPtr()); + } else { + xfer += proto->writeStructBegin("DataSet"); + xfer += proto->writeStructEnd(); + xfer += proto->writeFieldStop(); + } + xfer += proto->writeFieldEnd(); + break; + } + case nebula::Value::Type::GEOGRAPHY: { + xfer += proto->writeFieldBegin("ggVal", protocol::T_STRUCT, 16); + if (obj->getGeographyPtr()) { + xfer += Cpp2Ops::write(proto, obj->getGeographyPtr()); + } else { + xfer += proto->writeStructBegin("Geography"); + xfer += proto->writeStructEnd(); + xfer += proto->writeFieldStop(); + } + xfer += proto->writeFieldEnd(); + break; + } + case nebula::Value::Type::__EMPTY__: { + break; + } + } + + xfer += proto->writeFieldStop(); + xfer += proto->writeStructEnd(); + return xfer; +} + +template +void Cpp2Ops::read(Protocol* proto, nebula::Value* obj) { + apache::thrift::detail::ProtocolReaderStructReadState readState; + readState.fieldId = 0; + + readState.readStructBegin(proto); + + using apache::thrift::protocol::TProtocolException; + + readState.readFieldBegin(proto); + if (readState.fieldType == apache::thrift::protocol::T_STOP) { + obj->clear(); + } else { + if (proto->kUsesFieldNames()) { + detail::TccStructTraits::translateFieldName( + readState.fieldName(), readState.fieldId, readState.fieldType); + } + + switch (readState.fieldId) { + case 1: { + if (readState.fieldType == apache::thrift::protocol::T_I32) { + obj->setNull(nebula::NullType::__NULL__); + detail::pm::protocol_methods::read( + *proto, obj->mutableNull()); + } else { + proto->skip(readState.fieldType); + } + break; + } + case 2: { + if (readState.fieldType == apache::thrift::protocol::T_BOOL) { + obj->setBool(false); + proto->readBool(obj->mutableBool()); + } else { + proto->skip(readState.fieldType); + } + break; + } + case 3: { + if (readState.fieldType == apache::thrift::protocol::T_I64) { + obj->setInt(0); + detail::pm::protocol_methods::read( + *proto, obj->mutableInt()); + } else { + proto->skip(readState.fieldType); + } + break; + } + case 4: { + if (readState.fieldType == apache::thrift::protocol::T_DOUBLE) { + obj->setFloat(0.0); + proto->readDouble(obj->mutableFloat()); + } else { + proto->skip(readState.fieldType); + } + break; + } + case 5: { + if (readState.fieldType == apache::thrift::protocol::T_STRING) { + obj->setStr(""); + proto->readBinary(obj->mutableStr()); + } else { + proto->skip(readState.fieldType); + } + break; + } + case 6: { + if (readState.fieldType == apache::thrift::protocol::T_STRUCT) { + obj->setDate(nebula::Date()); + Cpp2Ops::read(proto, &obj->mutableDate()); + } else { + proto->skip(readState.fieldType); + } + break; + } + case 7: { + if (readState.fieldType == apache::thrift::protocol::T_STRUCT) { + obj->setTime(nebula::Time()); + Cpp2Ops::read(proto, &obj->mutableTime()); + } else { + proto->skip(readState.fieldType); + } + break; + } + case 8: { + if (readState.fieldType == apache::thrift::protocol::T_STRUCT) { + obj->setDateTime(nebula::DateTime()); + Cpp2Ops::read(proto, &obj->mutableDateTime()); + } else { + proto->skip(readState.fieldType); + } + break; + } + case 9: { + if (readState.fieldType == apache::thrift::protocol::T_STRUCT) { + obj->setVertex(nebula::Vertex()); + auto ptr = std::make_unique(); + Cpp2Ops::read(proto, ptr.get()); + obj->setVertex(std::move(ptr)); + } else { + proto->skip(readState.fieldType); + } + break; + } + case 10: { + if (readState.fieldType == apache::thrift::protocol::T_STRUCT) { + obj->setEdge(nebula::Edge()); + auto ptr = std::make_unique(); + Cpp2Ops::read(proto, ptr.get()); + obj->setEdge(std::move(ptr)); + } else { + proto->skip(readState.fieldType); + } + break; + } + case 11: { + if (readState.fieldType == apache::thrift::protocol::T_STRUCT) { + obj->setPath(nebula::Path()); + auto ptr = std::make_unique(); + Cpp2Ops::read(proto, ptr.get()); + obj->setPath(std::move(ptr)); + } else { + proto->skip(readState.fieldType); + } + break; + } + case 12: { + if (readState.fieldType == apache::thrift::protocol::T_STRUCT) { + obj->setList(nebula::List()); + auto ptr = std::make_unique(); + Cpp2Ops::read(proto, ptr.get()); + obj->setList(std::move(ptr)); + } else { + proto->skip(readState.fieldType); + } + break; + } + case 13: { + if (readState.fieldType == apache::thrift::protocol::T_STRUCT) { + obj->setMap(nebula::Map()); + auto ptr = std::make_unique(); + Cpp2Ops::read(proto, ptr.get()); + obj->setMap(std::move(ptr)); + } else { + proto->skip(readState.fieldType); + } + break; + } + case 14: { + if (readState.fieldType == apache::thrift::protocol::T_STRUCT) { + obj->setSet(nebula::Set()); + auto ptr = std::make_unique(); + Cpp2Ops::read(proto, ptr.get()); + obj->setSet(std::move(ptr)); + } else { + proto->skip(readState.fieldType); + } + break; + } + case 15: { + if (readState.fieldType == apache::thrift::protocol::T_STRUCT) { + obj->setDataSet(nebula::DataSet()); + auto ptr = std::make_unique(); + Cpp2Ops::read(proto, ptr.get()); + obj->setDataSet(std::move(ptr)); + } else { + proto->skip(readState.fieldType); + } + break; + } + case 16: { + if (readState.fieldType == apache::thrift::protocol::T_STRUCT) { + obj->setGeography(nebula::Geography()); + auto ptr = std::make_unique(); + Cpp2Ops::read(proto, ptr.get()); + obj->setGeography(std::move(ptr)); + } else { + proto->skip(readState.fieldType); + } + break; + } + default: { + proto->skip(readState.fieldType); + break; + } + } + + readState.readFieldEnd(proto); + readState.readFieldBegin(proto); + if (UNLIKELY(readState.fieldType != apache::thrift::protocol::T_STOP)) { + using apache::thrift::protocol::TProtocolException; + TProtocolException::throwUnionMissingStop(); + } + } + readState.readStructEnd(proto); +} + +template +uint32_t Cpp2Ops::serializedSize(Protocol const* proto, nebula::Value const* obj) { + uint32_t xfer = 0; + xfer += proto->serializedStructSize("Value"); + switch (obj->type()) { + case nebula::Value::Type::NULLVALUE: { + xfer += proto->serializedFieldSize("nVal", protocol::T_I32, 1); + xfer += detail::pm::protocol_methods:: + serializedSize(*proto, obj->getNull()); + break; + } + case nebula::Value::Type::BOOL: { + xfer += proto->serializedFieldSize("bVal", protocol::T_BOOL, 2); + xfer += proto->serializedSizeBool(obj->getBool()); + break; + } + case nebula::Value::Type::INT: { + xfer += proto->serializedFieldSize("iVal", protocol::T_I64, 3); + xfer += + detail::pm::protocol_methods::serializedSize( + *proto, obj->getInt()); + break; + } + case nebula::Value::Type::FLOAT: { + xfer += proto->serializedFieldSize("fVal", protocol::T_DOUBLE, 4); + xfer += proto->serializedSizeDouble(obj->getFloat()); + break; + } + case nebula::Value::Type::STRING: { + xfer += proto->serializedFieldSize("sVal", protocol::T_STRING, 5); + xfer += proto->serializedSizeBinary(obj->getStr()); + break; + } + case nebula::Value::Type::DATE: { + xfer += proto->serializedFieldSize("dVal", protocol::T_STRUCT, 6); + xfer += Cpp2Ops::serializedSize(proto, &obj->getDate()); + break; + } + case nebula::Value::Type::TIME: { + xfer += proto->serializedFieldSize("tVal", protocol::T_STRUCT, 7); + xfer += Cpp2Ops::serializedSize(proto, &obj->getTime()); + break; + } + case nebula::Value::Type::DATETIME: { + xfer += proto->serializedFieldSize("dtVal", protocol::T_STRUCT, 8); + xfer += Cpp2Ops::serializedSize(proto, &obj->getDateTime()); + break; + } + case nebula::Value::Type::VERTEX: { + xfer += proto->serializedFieldSize("vVal", protocol::T_STRUCT, 9); + if (obj->getVertexPtr()) { + xfer += Cpp2Ops::serializedSize(proto, obj->getVertexPtr()); + } else { + xfer += proto->serializedStructSize("Vertex"); + xfer += proto->serializedSizeStop(); + } + break; + } + case nebula::Value::Type::EDGE: { + xfer += proto->serializedFieldSize("eVal", protocol::T_STRUCT, 10); + if (obj->getEdgePtr()) { + xfer += Cpp2Ops::serializedSize(proto, obj->getEdgePtr()); + } else { + xfer += proto->serializedStructSize("Edge"); + xfer += proto->serializedSizeStop(); + } + break; + } + case nebula::Value::Type::PATH: { + xfer += proto->serializedFieldSize("pVal", protocol::T_STRUCT, 11); + if (obj->getPathPtr()) { + xfer += Cpp2Ops::serializedSize(proto, obj->getPathPtr()); + } else { + xfer += proto->serializedStructSize("Path"); + xfer += proto->serializedSizeStop(); + } + break; + } + case nebula::Value::Type::LIST: { + xfer += proto->serializedFieldSize("lVal", protocol::T_STRUCT, 12); + if (obj->getListPtr()) { + xfer += Cpp2Ops::serializedSize(proto, obj->getListPtr()); + } else { + xfer += proto->serializedStructSize("NList"); + xfer += proto->serializedSizeStop(); + } + break; + } + case nebula::Value::Type::MAP: { + xfer += proto->serializedFieldSize("mVal", protocol::T_STRUCT, 13); + if (obj->getMapPtr()) { + xfer += Cpp2Ops::serializedSize(proto, obj->getMapPtr()); + } else { + xfer += proto->serializedStructSize("NMap"); + xfer += proto->serializedSizeStop(); + } + break; + } + case nebula::Value::Type::SET: { + xfer += proto->serializedFieldSize("uVal", protocol::T_STRUCT, 14); + if (obj->getSetPtr()) { + xfer += Cpp2Ops::serializedSize(proto, obj->getSetPtr()); + } else { + xfer += proto->serializedStructSize("NSet"); + xfer += proto->serializedSizeStop(); + } + break; + } + case nebula::Value::Type::DATASET: { + xfer += proto->serializedFieldSize("gVal", protocol::T_STRUCT, 15); + if (obj->getDataSetPtr()) { + xfer += Cpp2Ops::serializedSize(proto, obj->getDataSetPtr()); + } else { + xfer += proto->serializedStructSize("DataSet"); + xfer += proto->serializedSizeStop(); + } + break; + } + case nebula::Value::Type::GEOGRAPHY: { + xfer += proto->serializedFieldSize("ggVal", protocol::T_STRUCT, 16); + if (obj->getGeographyPtr()) { + xfer += Cpp2Ops::serializedSize(proto, obj->getGeographyPtr()); + } else { + xfer += proto->serializedStructSize("Geography"); + xfer += proto->serializedSizeStop(); + } + break; + } + case nebula::Value::Type::__EMPTY__: { + break; + } + } + + xfer += proto->serializedSizeStop(); + return xfer; +} + +template +uint32_t Cpp2Ops::serializedSizeZC(Protocol const* proto, nebula::Value const* obj) { + uint32_t xfer = 0; + xfer += proto->serializedStructSize("Value"); + + switch (obj->type()) { + case nebula::Value::Type::NULLVALUE: { + xfer += proto->serializedFieldSize("nVal", protocol::T_I32, 1); + xfer += detail::pm::protocol_methods:: + serializedSize(*proto, obj->getNull()); + break; + } + case nebula::Value::Type::BOOL: { + xfer += proto->serializedFieldSize("bVal", protocol::T_BOOL, 2); + xfer += proto->serializedSizeBool(obj->getBool()); + break; + } + case nebula::Value::Type::INT: { + xfer += proto->serializedFieldSize("iVal", protocol::T_I64, 3); + xfer += + detail::pm::protocol_methods::serializedSize( + *proto, obj->getInt()); + break; + } + case nebula::Value::Type::FLOAT: { + xfer += proto->serializedFieldSize("fVal", protocol::T_DOUBLE, 4); + xfer += proto->serializedSizeDouble(obj->getFloat()); + break; + } + case nebula::Value::Type::STRING: { + xfer += proto->serializedFieldSize("sVal", protocol::T_STRING, 5); + xfer += proto->serializedSizeZCBinary(obj->getStr()); + break; + } + case nebula::Value::Type::DATE: { + xfer += proto->serializedFieldSize("dVal", protocol::T_STRUCT, 6); + xfer += Cpp2Ops::serializedSizeZC(proto, &obj->getDate()); + break; + } + case nebula::Value::Type::TIME: { + xfer += proto->serializedFieldSize("tVal", protocol::T_STRUCT, 7); + xfer += Cpp2Ops::serializedSizeZC(proto, &obj->getTime()); + break; + } + case nebula::Value::Type::DATETIME: { + xfer += proto->serializedFieldSize("dtVal", protocol::T_STRUCT, 8); + xfer += Cpp2Ops::serializedSizeZC(proto, &obj->getDateTime()); + break; + } + case nebula::Value::Type::VERTEX: { + xfer += proto->serializedFieldSize("vVal", protocol::T_STRUCT, 9); + if (obj->getVertexPtr()) { + xfer += Cpp2Ops::serializedSizeZC(proto, obj->getVertexPtr()); + } else { + xfer += proto->serializedStructSize("Vertex"); + xfer += proto->serializedSizeStop(); + } + break; + } + case nebula::Value::Type::EDGE: { + xfer += proto->serializedFieldSize("eVal", protocol::T_STRUCT, 10); + if (obj->getEdgePtr()) { + xfer += Cpp2Ops::serializedSizeZC(proto, obj->getEdgePtr()); + } else { + xfer += proto->serializedStructSize("Edge"); + xfer += proto->serializedSizeStop(); + } + break; + } + case nebula::Value::Type::PATH: { + xfer += proto->serializedFieldSize("pVal", protocol::T_STRUCT, 11); + if (obj->getPathPtr()) { + xfer += Cpp2Ops::serializedSizeZC(proto, obj->getPathPtr()); + } else { + xfer += proto->serializedStructSize("Path"); + xfer += proto->serializedSizeStop(); + } + break; + } + case nebula::Value::Type::LIST: { + xfer += proto->serializedFieldSize("lVal", protocol::T_STRUCT, 12); + if (obj->getListPtr()) { + xfer += Cpp2Ops::serializedSizeZC(proto, obj->getListPtr()); + } else { + xfer += proto->serializedStructSize("NList"); + xfer += proto->serializedSizeStop(); + } + break; + } + case nebula::Value::Type::MAP: { + xfer += proto->serializedFieldSize("mVal", protocol::T_STRUCT, 13); + if (obj->getMapPtr()) { + xfer += Cpp2Ops::serializedSizeZC(proto, obj->getMapPtr()); + } else { + xfer += proto->serializedStructSize("NMap"); + xfer += proto->serializedSizeStop(); + } + break; + } + case nebula::Value::Type::SET: { + xfer += proto->serializedFieldSize("uVal", protocol::T_STRUCT, 14); + if (obj->getSetPtr()) { + xfer += Cpp2Ops::serializedSizeZC(proto, obj->getSetPtr()); + } else { + xfer += proto->serializedStructSize("NSet"); + xfer += proto->serializedSizeStop(); + } + break; + } + case nebula::Value::Type::DATASET: { + xfer += proto->serializedFieldSize("gVal", protocol::T_STRUCT, 15); + if (obj->getDataSetPtr()) { + xfer += Cpp2Ops::serializedSizeZC(proto, obj->getDataSetPtr()); + } else { + xfer += proto->serializedStructSize("DataSet"); + xfer += proto->serializedSizeStop(); + } + break; + } + case nebula::Value::Type::GEOGRAPHY: { + xfer += proto->serializedFieldSize("ggVal", protocol::T_STRUCT, 16); + if (obj->getGeographyPtr()) { + xfer += Cpp2Ops::serializedSizeZC(proto, obj->getGeographyPtr()); + } else { + xfer += proto->serializedStructSize("Geography"); + xfer += proto->serializedSizeStop(); + } + break; + } + case nebula::Value::Type::__EMPTY__: { + break; + } + } + + xfer += proto->serializedSizeStop(); + return xfer; +} + +} // namespace thrift +} // namespace apache diff --git a/include/common/datatypes/Vertex.h b/include/common/datatypes/Vertex.h new file mode 100644 index 00000000..9d1cbcf0 --- /dev/null +++ b/include/common/datatypes/Vertex.h @@ -0,0 +1,120 @@ +/* Copyright (c) 2020 vesoft inc. All rights reserved. + * + * This source code is licensed under Apache 2.0 License, + * attached with Common Clause Condition 1.0, found in the LICENSES directory. + */ + +#pragma once + +#include +#include +#include + +#include "common/datatypes/Value.h" +#include "common/thrift/ThriftTypes.h" + +namespace nebula { + +struct Tag { + std::string name; + std::unordered_map props; + + Tag() = default; + Tag(Tag&& tag) noexcept : name(std::move(tag.name)), props(std::move(tag.props)) {} + Tag(const Tag& tag) : name(tag.name), props(tag.props) {} + Tag(std::string tagName, std::unordered_map tagProps) + : name(std::move(tagName)), props(std::move(tagProps)) {} + + void clear() { + name.clear(); + props.clear(); + } + + void __clear() { + clear(); + } + + std::string toString() const; + + Tag& operator=(Tag&& rhs) noexcept { + if (&rhs != this) { + name = std::move(rhs.name); + props = std::move(rhs.props); + } + return *this; + } + + Tag& operator=(const Tag& rhs) { + if (&rhs != this) { + name = rhs.name; + props = rhs.props; + } + return *this; + } + + bool operator==(const Tag& rhs) const { + return name == rhs.name && props == rhs.props; + } +}; + +struct Vertex { + Value vid; + std::vector tags; + + Vertex() = default; + Vertex(const Vertex& v) : vid(v.vid), tags(v.tags) {} + Vertex(Vertex&& v) noexcept : vid(std::move(v.vid)), tags(std::move(v.tags)) {} + Vertex(Value id, std::vector t) : vid(std::move(id)), tags(std::move(t)) {} + + void clear() { + vid.clear(); + tags.clear(); + } + + void __clear() { + clear(); + } + + std::string toString() const; + + Vertex& operator=(Vertex&& rhs) noexcept; + + Vertex& operator=(const Vertex& rhs); + + bool operator==(const Vertex& rhs) const { + return vid == rhs.vid && tags == rhs.tags; + } + + bool operator<(const Vertex& rhs) const; + + bool contains(const Value& key) const; + + const Value& value(const std::string& key) const; +}; + +inline void swap(Vertex& a, Vertex& b) { + auto temp = std::move(a); + a = std::move(b); + b = std::move(temp); +} + +inline std::ostream& operator<<(std::ostream& os, const Vertex& v) { + return os << v.toString(); +} + +} // namespace nebula + +namespace std { + +// Inject a customized hash function +template <> +struct hash { + std::size_t operator()(const nebula::Tag& h) const noexcept; +}; + +template <> +struct hash { + std::size_t operator()(const nebula::Vertex& h) const noexcept; +}; + +} // namespace std diff --git a/include/common/datatypes/VertexOps-inl.h b/include/common/datatypes/VertexOps-inl.h new file mode 100644 index 00000000..794e7377 --- /dev/null +++ b/include/common/datatypes/VertexOps-inl.h @@ -0,0 +1,315 @@ +/* Copyright (c) 2020 vesoft inc. All rights reserved. + * + * This source code is licensed under Apache 2.0 License, + * attached with Common Clause Condition 1.0, found in the LICENSES directory. + */ + +#pragma once + +#include +#include +#include + +#include "common/datatypes/CommonCpp2Ops.h" +#include "common/datatypes/Vertex.h" +#include "common/utils/utils.h" + +namespace apache { +namespace thrift { + +/************************************** + * + * Ops for class Tag + * + *************************************/ +namespace detail { + +template <> +struct TccStructTraits { + static void translateFieldName(MAYBE_UNUSED folly::StringPiece _fname, + MAYBE_UNUSED int16_t& fid, + MAYBE_UNUSED apache::thrift::protocol::TType& _ftype) { + if (_fname == "name") { + fid = 1; + _ftype = apache::thrift::protocol::T_STRING; + } else if (_fname == "props") { + fid = 2; + _ftype = apache::thrift::protocol::T_MAP; + } + } +}; + +} // namespace detail + +inline constexpr apache::thrift::protocol::TType Cpp2Ops::thriftType() { + return apache::thrift::protocol::T_STRUCT; +} + +template +uint32_t Cpp2Ops::write(Protocol* proto, nebula::Tag const* obj) { + uint32_t xfer = 0; + xfer += proto->writeStructBegin("Tag"); + + xfer += proto->writeFieldBegin("name", apache::thrift::protocol::T_STRING, 1); + xfer += proto->writeBinary(obj->name); + xfer += proto->writeFieldEnd(); + + xfer += proto->writeFieldBegin("props", apache::thrift::protocol::T_MAP, 2); + xfer += detail::pm::protocol_methods< + type_class::map, + std::unordered_map>::write(*proto, obj->props); + xfer += proto->writeFieldEnd(); + + xfer += proto->writeFieldStop(); + xfer += proto->writeStructEnd(); + return xfer; +} + +template +void Cpp2Ops::read(Protocol* proto, nebula::Tag* obj) { + apache::thrift::detail::ProtocolReaderStructReadState readState; + + readState.readStructBegin(proto); + + using apache::thrift::protocol::TProtocolException; + + if (UNLIKELY(!readState.advanceToNextField(proto, 0, 1, protocol::T_STRING))) { + goto _loop; + } + +_readField_name : { proto->readBinary(obj->name); } + + if (UNLIKELY(!readState.advanceToNextField(proto, 1, 2, protocol::T_MAP))) { + goto _loop; + } + +_readField_props : { + obj->props = std::unordered_map(); + detail::pm::protocol_methods, + std::unordered_map>::read(*proto, + obj->props); +} + + if (UNLIKELY(!readState.advanceToNextField(proto, 2, 0, protocol::T_STOP))) { + goto _loop; + } + +_end: + readState.readStructEnd(proto); + + return; + +_loop: + if (readState.fieldType == apache::thrift::protocol::T_STOP) { + goto _end; + } + + if (proto->kUsesFieldNames()) { + detail::TccStructTraits::translateFieldName( + readState.fieldName(), readState.fieldId, readState.fieldType); + } + + switch (readState.fieldId) { + case 1: { + if (LIKELY(readState.fieldType == apache::thrift::protocol::T_STRING)) { + goto _readField_name; + } else { + goto _skip; + } + } + case 2: { + if (LIKELY(readState.fieldType == apache::thrift::protocol::T_MAP)) { + goto _readField_props; + } else { + goto _skip; + } + } + default: { + _skip: + proto->skip(readState.fieldType); + readState.readFieldEnd(proto); + readState.readFieldBeginNoInline(proto); + goto _loop; + } + } +} + +template +uint32_t Cpp2Ops::serializedSize(Protocol const* proto, nebula::Tag const* obj) { + uint32_t xfer = 0; + xfer += proto->serializedStructSize("Tag"); + + xfer += proto->serializedFieldSize("name", apache::thrift::protocol::T_STRING, 1); + xfer += proto->serializedSizeBinary(obj->name); + + xfer += proto->serializedFieldSize("props", apache::thrift::protocol::T_MAP, 2); + xfer += detail::pm::protocol_methods< + type_class::map, + std::unordered_map>::serializedSize(*proto, obj->props); + + xfer += proto->serializedSizeStop(); + return xfer; +} + +template +uint32_t Cpp2Ops::serializedSizeZC(Protocol const* proto, nebula::Tag const* obj) { + uint32_t xfer = 0; + xfer += proto->serializedStructSize("Tag"); + + xfer += proto->serializedFieldSize("name", apache::thrift::protocol::T_STRING, 1); + xfer += proto->serializedSizeZCBinary(obj->name); + + xfer += proto->serializedFieldSize("props", apache::thrift::protocol::T_MAP, 2); + xfer += detail::pm::protocol_methods< + type_class::map, + std::unordered_map>::serializedSize(*proto, obj->props); + + xfer += proto->serializedSizeStop(); + return xfer; +} + +/************************************** + * + * Ops for class Vertex + * + *************************************/ +namespace detail { + +template <> +struct TccStructTraits { + static void translateFieldName(MAYBE_UNUSED folly::StringPiece _fname, + MAYBE_UNUSED int16_t& fid, + MAYBE_UNUSED apache::thrift::protocol::TType& _ftype) { + if (_fname == "vid") { + fid = 1; + _ftype = apache::thrift::protocol::T_STRUCT; + } else if (_fname == "tags") { + fid = 2; + _ftype = apache::thrift::protocol::T_LIST; + } + } +}; + +} // namespace detail + +inline constexpr protocol::TType Cpp2Ops::thriftType() { + return apache::thrift::protocol::T_STRUCT; +} + +template +uint32_t Cpp2Ops::write(Protocol* proto, nebula::Vertex const* obj) { + uint32_t xfer = 0; + xfer += proto->writeStructBegin("Vertex"); + xfer += proto->writeFieldBegin("vid", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::Cpp2Ops::write(proto, &obj->vid); + xfer += proto->writeFieldEnd(); + xfer += proto->writeFieldBegin("tags", apache::thrift::protocol::T_LIST, 2); + xfer += detail::pm::protocol_methods, + std::vector>::write(*proto, obj->tags); + xfer += proto->writeFieldEnd(); + xfer += proto->writeFieldStop(); + xfer += proto->writeStructEnd(); + return xfer; +} + +template +void Cpp2Ops::read(Protocol* proto, nebula::Vertex* obj) { + detail::ProtocolReaderStructReadState readState; + + readState.readStructBegin(proto); + + using apache::thrift::protocol::TProtocolException; + + if (UNLIKELY(!readState.advanceToNextField(proto, 0, 1, protocol::T_STRUCT))) { + goto _loop; + } + +_readField_vid : { ::apache::thrift::Cpp2Ops::read(proto, &obj->vid); } + + if (UNLIKELY(!readState.advanceToNextField(proto, 1, 2, protocol::T_LIST))) { + goto _loop; + } + +_readField_tags : { + obj->tags = std::vector(); + detail::pm::protocol_methods, + std::vector>::read(*proto, obj->tags); +} + + if (UNLIKELY(!readState.advanceToNextField(proto, 2, 0, protocol::T_STOP))) { + goto _loop; + } + +_end: + readState.readStructEnd(proto); + + return; + +_loop: + if (readState.fieldType == apache::thrift::protocol::T_STOP) { + goto _end; + } + + if (proto->kUsesFieldNames()) { + detail::TccStructTraits::translateFieldName( + readState.fieldName(), readState.fieldId, readState.fieldType); + } + + switch (readState.fieldId) { + case 1: { + if (LIKELY(readState.fieldType == apache::thrift::protocol::T_STRUCT)) { + goto _readField_vid; + } else { + goto _skip; + } + } + case 2: { + if (LIKELY(readState.fieldType == apache::thrift::protocol::T_LIST)) { + goto _readField_tags; + } else { + goto _skip; + } + } + default: { + _skip: + proto->skip(readState.fieldType); + readState.readFieldEnd(proto); + readState.readFieldBeginNoInline(proto); + goto _loop; + } + } +} + +template +uint32_t Cpp2Ops::serializedSize(Protocol const* proto, nebula::Vertex const* obj) { + uint32_t xfer = 0; + xfer += proto->serializedStructSize("Vertex"); + xfer += proto->serializedFieldSize("vid", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::Cpp2Ops::serializedSize(proto, &obj->vid); + xfer += proto->serializedFieldSize("tags", apache::thrift::protocol::T_LIST, 2); + xfer += + detail::pm::protocol_methods, + std::vector>::serializedSize(*proto, + obj->tags); + xfer += proto->serializedSizeStop(); + return xfer; +} + +template +uint32_t Cpp2Ops::serializedSizeZC(Protocol const* proto, + nebula::Vertex const* obj) { + uint32_t xfer = 0; + xfer += proto->serializedStructSize("Vertex"); + xfer += proto->serializedFieldSize("vid", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::Cpp2Ops::serializedSizeZC(proto, &obj->vid); + xfer += proto->serializedFieldSize("tags", apache::thrift::protocol::T_LIST, 2); + xfer += + detail::pm::protocol_methods, + std::vector>::serializedSize(*proto, + obj->tags); + xfer += proto->serializedSizeStop(); + return xfer; +} + +} // namespace thrift +} // namespace apache diff --git a/include/common/graph/AuthResponseOps-inl.h b/include/common/graph/AuthResponseOps-inl.h new file mode 100644 index 00000000..2744b2c9 --- /dev/null +++ b/include/common/graph/AuthResponseOps-inl.h @@ -0,0 +1,294 @@ +/* Copyright (c) 2020 vesoft inc. All rights reserved. + * + * This source code is licensed under Apache 2.0 License, + * attached with Common Clause Condition 1.0, found in the LICENSES directory. + */ + +#pragma once + +#include +#include +#include + +#include + +#include "common/graph/GraphCpp2Ops.h" +#include "common/graph/Response.h" +#include "common/utils/utils.h" + +namespace apache { +namespace thrift { + +/************************************** + * + * Ops for class AuthResponse + * + *************************************/ +namespace detail { + +template <> +struct TccStructTraits { + static void translateFieldName(MAYBE_UNUSED folly::StringPiece _fname, + MAYBE_UNUSED int16_t& fid, + MAYBE_UNUSED apache::thrift::protocol::TType& _ftype) { + if (false) { + } else if (_fname == "error_code") { + fid = 1; + _ftype = apache::thrift::protocol::T_I32; + } else if (_fname == "error_msg") { + fid = 2; + _ftype = apache::thrift::protocol::T_STRING; + } else if (_fname == "session_id") { + fid = 3; + _ftype = apache::thrift::protocol::T_I64; + } else if (_fname == "time_zone_offset_seconds") { + fid = 4; + _ftype = apache::thrift::protocol::T_I32; + } else if (_fname == "time_zone_name") { + fid = 5; + _ftype = apache::thrift::protocol::T_STRING; + } + } +}; + +} // namespace detail + +inline constexpr apache::thrift::protocol::TType Cpp2Ops<::nebula::AuthResponse>::thriftType() { + return apache::thrift::protocol::T_STRUCT; +} + +template +uint32_t Cpp2Ops<::nebula::AuthResponse>::write(Protocol* proto, + ::nebula::AuthResponse const* obj) { + uint32_t xfer = 0; + xfer += proto->writeStructBegin("nebula::AuthResponse"); + xfer += proto->writeFieldBegin("error_code", apache::thrift::protocol::T_I32, 1); + xfer += + ::apache::thrift::detail::pm::protocol_methods<::apache::thrift::type_class::enumeration, + ::nebula::ErrorCode>::write(*proto, + obj->errorCode); + xfer += proto->writeFieldEnd(); + if (obj->errorMsg != nullptr) { + xfer += proto->writeFieldBegin("error_msg", apache::thrift::protocol::T_STRING, 2); + xfer += proto->writeBinary(*obj->errorMsg); + xfer += proto->writeFieldEnd(); + } + if (obj->sessionId != nullptr) { + xfer += proto->writeFieldBegin("session_id", apache::thrift::protocol::T_I64, 3); + xfer += + ::apache::thrift::detail::pm::protocol_methods<::apache::thrift::type_class::integral, + int64_t>::write(*proto, *obj->sessionId); + xfer += proto->writeFieldEnd(); + } + if (obj->timeZoneOffsetSeconds != nullptr) { + xfer += + proto->writeFieldBegin("time_zone_offset_seconds", apache::thrift::protocol::T_I32, 4); + xfer += ::apache::thrift::detail::pm:: + protocol_methods<::apache::thrift::type_class::integral, int32_t>::write( + *proto, *obj->timeZoneOffsetSeconds); + xfer += proto->writeFieldEnd(); + } + if (obj->timeZoneName != nullptr) { + xfer += proto->writeFieldBegin("time_zone_name", apache::thrift::protocol::T_STRING, 5); + xfer += proto->writeBinary(*obj->timeZoneName); + xfer += proto->writeFieldEnd(); + } + xfer += proto->writeFieldStop(); + xfer += proto->writeStructEnd(); + return xfer; +} + +template +void Cpp2Ops<::nebula::AuthResponse>::read(Protocol* proto, ::nebula::AuthResponse* obj) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(proto); + + using apache::thrift::TProtocolException; + + bool isset_error_code = false; + + if (UNLIKELY(!_readState.advanceToNextField(proto, 0, 1, apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_error_code : { + ::apache::thrift::detail::pm::protocol_methods<::apache::thrift::type_class::enumeration, + ::nebula::ErrorCode>::read(*proto, + obj->errorCode); + isset_error_code = true; +} + + if (UNLIKELY(!_readState.advanceToNextField(proto, 1, 2, apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_error_msg : { + obj->errorMsg = std::make_unique(); + proto->readBinary(*obj->errorMsg); + // this->__isset.error_msg = true; +} + + if (UNLIKELY(!_readState.advanceToNextField(proto, 2, 3, apache::thrift::protocol::T_I64))) { + goto _loop; + } +_readField_session_id : { + obj->sessionId = std::make_unique(-1); + ::apache::thrift::detail::pm::protocol_methods<::apache::thrift::type_class::integral, + int64_t>::read(*proto, *obj->sessionId); + // this->__isset.session_id = true; +} + + if (UNLIKELY(!_readState.advanceToNextField(proto, 3, 4, apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_time_zone_offset_seconds : { + obj->timeZoneOffsetSeconds = std::make_unique(0); + ::apache::thrift::detail::pm::protocol_methods<::apache::thrift::type_class::integral, + int32_t>::read(*proto, + *obj->timeZoneOffsetSeconds); +} + + if (UNLIKELY(!_readState.advanceToNextField(proto, 4, 5, apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_time_zone_name : { + obj->timeZoneName = std::make_unique(); + proto->readBinary(*obj->timeZoneName); +} + + if (UNLIKELY(!_readState.advanceToNextField(proto, 5, 0, apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(proto); + + if (!isset_error_code) { + TProtocolException::throwMissingRequiredField("error_code", "nebula::AuthResponse"); + } + return; + +_loop: + if (_readState.fieldType == apache::thrift::protocol::T_STOP) { + goto _end; + } + if (proto->kUsesFieldNames()) { + apache::thrift::detail::TccStructTraits::translateFieldName( + _readState.fieldName(), _readState.fieldId, _readState.fieldType); + } + + switch (_readState.fieldId) { + case 1: { + if (LIKELY(_readState.fieldType == apache::thrift::protocol::T_I32)) { + goto _readField_error_code; + } else { + goto _skip; + } + } + case 2: { + if (LIKELY(_readState.fieldType == apache::thrift::protocol::T_STRING)) { + goto _readField_error_msg; + } else { + goto _skip; + } + } + case 3: { + if (LIKELY(_readState.fieldType == apache::thrift::protocol::T_I64)) { + goto _readField_session_id; + } else { + goto _skip; + } + } + case 4: { + if (LIKELY(_readState.fieldType == apache::thrift::protocol::T_I32)) { + goto _readField_time_zone_offset_seconds; + } else { + goto _skip; + } + } + case 5: { + if (LIKELY(_readState.fieldType == apache::thrift::protocol::T_STRING)) { + goto _readField_time_zone_name; + } else { + goto _skip; + } + } + default: { + _skip: + proto->skip(_readState.fieldType); + _readState.readFieldEnd(proto); + _readState.readFieldBeginNoInline(proto); + goto _loop; + } + } +} + +template +uint32_t Cpp2Ops<::nebula::AuthResponse>::serializedSize(Protocol const* proto, + ::nebula::AuthResponse const* obj) { + uint32_t xfer = 0; + xfer += proto->serializedStructSize("nebula::AuthResponse"); + xfer += proto->serializedFieldSize("error_code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< + ::apache::thrift::type_class::enumeration, + ::nebula::ErrorCode>::serializedSize(*proto, obj->errorCode); + if (obj->errorMsg != nullptr) { + xfer += proto->serializedFieldSize("error_msg", apache::thrift::protocol::T_STRING, 2); + xfer += proto->serializedSizeBinary(*obj->errorMsg); + } + if (obj->sessionId != nullptr) { + xfer += proto->serializedFieldSize("session_id", apache::thrift::protocol::T_I64, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< + ::apache::thrift::type_class::integral, + int64_t>::serializedSize(*proto, *obj->sessionId); + } + if (obj->timeZoneOffsetSeconds != nullptr) { + xfer += proto->serializedFieldSize( + "time_zone_offset_seconds", apache::thrift::protocol::T_I32, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< + ::apache::thrift::type_class::integral, + int64_t>::serializedSize(*proto, *obj->timeZoneOffsetSeconds); + } + if (obj->timeZoneName != nullptr) { + xfer += proto->serializedFieldSize("time_zone_name", apache::thrift::protocol::T_STRING, 5); + xfer += proto->serializedSizeBinary(*obj->timeZoneName); + } + xfer += proto->serializedSizeStop(); + return xfer; +} + +template +uint32_t Cpp2Ops<::nebula::AuthResponse>::serializedSizeZC(Protocol const* proto, + ::nebula::AuthResponse const* obj) { + uint32_t xfer = 0; + xfer += proto->serializedStructSize("nebula::AuthResponse"); + xfer += proto->serializedFieldSize("error_code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< + ::apache::thrift::type_class::enumeration, + ::nebula::ErrorCode>::serializedSize(*proto, obj->errorCode); + if (obj->errorMsg != nullptr) { + xfer += proto->serializedFieldSize("error_msg", apache::thrift::protocol::T_STRING, 2); + xfer += proto->serializedSizeZCBinary(*obj->errorMsg); + } + if (obj->sessionId != nullptr) { + xfer += proto->serializedFieldSize("session_id", apache::thrift::protocol::T_I64, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< + ::apache::thrift::type_class::integral, + int64_t>::serializedSize(*proto, *obj->sessionId); + } + if (obj->timeZoneOffsetSeconds != nullptr) { + xfer += proto->serializedFieldSize( + "time_zone_offset_seconds", apache::thrift::protocol::T_I32, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< + ::apache::thrift::type_class::integral, + int64_t>::serializedSize(*proto, *obj->timeZoneOffsetSeconds); + } + if (obj->timeZoneName != nullptr) { + xfer += proto->serializedFieldSize("time_zone_name", apache::thrift::protocol::T_STRING, 5); + xfer += proto->serializedSizeZCBinary(*obj->timeZoneName); + } + xfer += proto->serializedSizeStop(); + return xfer; +} + +} // namespace thrift +} // namespace apache diff --git a/include/common/graph/ExecutionResponseOps-inl.h b/include/common/graph/ExecutionResponseOps-inl.h new file mode 100644 index 00000000..7215728b --- /dev/null +++ b/include/common/graph/ExecutionResponseOps-inl.h @@ -0,0 +1,353 @@ +/* Copyright (c) 2020 vesoft inc. All rights reserved. + * + * This source code is licensed under Apache 2.0 License, + * attached with Common Clause Condition 1.0, found in the LICENSES directory. + */ + +#pragma once + +#include +#include +#include + +#include + +#include "common/graph/GraphCpp2Ops.h" +#include "common/graph/Response.h" +#include "common/utils/utils.h" + +namespace apache { +namespace thrift { + +/************************************** + * + * Ops for class ExecutionResponse + * + *************************************/ +namespace detail { + +template <> +struct TccStructTraits<::nebula::ExecutionResponse> { + static void translateFieldName(MAYBE_UNUSED folly::StringPiece _fname, + MAYBE_UNUSED int16_t& fid, + MAYBE_UNUSED apache::thrift::protocol::TType& _ftype) { + if (false) { + } else if (_fname == "error_code") { + fid = 1; + _ftype = apache::thrift::protocol::T_I32; + } else if (_fname == "latency_in_us") { + fid = 2; + _ftype = apache::thrift::protocol::T_I32; + } else if (_fname == "data") { + fid = 3; + _ftype = apache::thrift::protocol::T_STRUCT; + } else if (_fname == "space_name") { + fid = 4; + _ftype = apache::thrift::protocol::T_STRING; + } else if (_fname == "error_msg") { + fid = 5; + _ftype = apache::thrift::protocol::T_STRING; + } else if (_fname == "plan_desc") { + fid = 6; + _ftype = apache::thrift::protocol::T_STRUCT; + } else if (_fname == "comment") { + fid = 7; + _ftype = apache::thrift::protocol::T_STRING; + } + } +}; + +} // namespace detail + +inline constexpr apache::thrift::protocol::TType +Cpp2Ops<::nebula::ExecutionResponse>::thriftType() { + return apache::thrift::protocol::T_STRUCT; +} + +template +uint32_t Cpp2Ops<::nebula::ExecutionResponse>::write(Protocol* proto, + ::nebula::ExecutionResponse const* obj) { + uint32_t xfer = 0; + xfer += proto->writeStructBegin("ExecutionResponse"); + xfer += proto->writeFieldBegin("error_code", apache::thrift::protocol::T_I32, 1); + xfer += + ::apache::thrift::detail::pm::protocol_methods<::apache::thrift::type_class::enumeration, + ::nebula::ErrorCode>::write(*proto, + obj->errorCode); + xfer += proto->writeFieldEnd(); + xfer += proto->writeFieldBegin("latency_in_us", apache::thrift::protocol::T_I32, 2); + xfer += + ::apache::thrift::detail::pm::protocol_methods<::apache::thrift::type_class::integral, + int32_t>::write(*proto, obj->latencyInUs); + xfer += proto->writeFieldEnd(); + if (obj->data != nullptr) { + xfer += proto->writeFieldBegin("data", apache::thrift::protocol::T_STRUCT, 3); + xfer += ::apache::thrift::Cpp2Ops::write(proto, obj->data.get()); + xfer += proto->writeFieldEnd(); + } + if (obj->spaceName != nullptr) { + xfer += proto->writeFieldBegin("space_name", apache::thrift::protocol::T_STRING, 4); + xfer += proto->writeBinary(*obj->spaceName); + xfer += proto->writeFieldEnd(); + } + if (obj->errorMsg != nullptr) { + xfer += proto->writeFieldBegin("error_msg", apache::thrift::protocol::T_STRING, 5); + xfer += proto->writeBinary(*obj->errorMsg); + xfer += proto->writeFieldEnd(); + } + if (obj->planDesc != nullptr) { + xfer += proto->writeFieldBegin("plan_desc", apache::thrift::protocol::T_STRUCT, 6); + xfer += + ::apache::thrift::Cpp2Ops<::nebula::PlanDescription>::write(proto, obj->planDesc.get()); + xfer += proto->writeFieldEnd(); + } + if (obj->comment != nullptr) { + xfer += proto->writeFieldBegin("comment", apache::thrift::protocol::T_STRING, 7); + xfer += proto->writeBinary(*obj->comment); + xfer += proto->writeFieldEnd(); + } + xfer += proto->writeFieldStop(); + xfer += proto->writeStructEnd(); + return xfer; +} + +template +void Cpp2Ops<::nebula::ExecutionResponse>::read(Protocol* proto, ::nebula::ExecutionResponse* obj) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(proto); + + using apache::thrift::TProtocolException; + + bool isset_error_code = false; + bool isset_latency_in_us = false; + + if (UNLIKELY(!_readState.advanceToNextField(proto, 0, 1, apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_error_code : { + ::apache::thrift::detail::pm::protocol_methods<::apache::thrift::type_class::enumeration, + ::nebula::ErrorCode>::read(*proto, + obj->errorCode); + isset_error_code = true; +} + + if (UNLIKELY(!_readState.advanceToNextField(proto, 1, 2, apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_latency_in_us : { + ::apache::thrift::detail::pm::protocol_methods<::apache::thrift::type_class::integral, + int32_t>::read(*proto, obj->latencyInUs); + isset_latency_in_us = true; +} + + if (UNLIKELY(!_readState.advanceToNextField(proto, 2, 3, apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_data : { + obj->data = std::make_unique(); + ::apache::thrift::Cpp2Ops::read(proto, obj->data.get()); + // this->__isset.data = true; +} + + if (UNLIKELY(!_readState.advanceToNextField(proto, 3, 4, apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_space_name : { + obj->spaceName = std::make_unique(); + proto->readBinary(*obj->spaceName); + // this->__isset.space_name = true; +} + + if (UNLIKELY(!_readState.advanceToNextField(proto, 4, 5, apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_error_msg : { + obj->errorMsg = std::make_unique(); + proto->readBinary(*obj->errorMsg); + // this->__isset.error_msg = true; +} + + if (UNLIKELY(!_readState.advanceToNextField(proto, 5, 6, apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_plan_desc : { + obj->planDesc = std::make_unique<::nebula::PlanDescription>(); + ::apache::thrift::Cpp2Ops<::nebula::PlanDescription>::read(proto, obj->planDesc.get()); + // this->__isset.plan_desc = true; +} + + if (UNLIKELY(!_readState.advanceToNextField(proto, 6, 7, apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_comment : { + obj->comment = std::make_unique(); + proto->readBinary(*obj->comment); + // this->__isset.comment = true; +} + + if (UNLIKELY(!_readState.advanceToNextField(proto, 7, 0, apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(proto); + + if (!isset_error_code) { + TProtocolException::throwMissingRequiredField("error_code", "ExecutionResponse"); + } + if (!isset_latency_in_us) { + TProtocolException::throwMissingRequiredField("latency_in_us", "ExecutionResponse"); + } + return; + +_loop: + if (_readState.fieldType == apache::thrift::protocol::T_STOP) { + goto _end; + } + if (proto->kUsesFieldNames()) { + apache::thrift::detail::TccStructTraits::translateFieldName( + _readState.fieldName(), _readState.fieldId, _readState.fieldType); + } + + switch (_readState.fieldId) { + case 1: { + if (LIKELY(_readState.fieldType == apache::thrift::protocol::T_I32)) { + goto _readField_error_code; + } else { + goto _skip; + } + } + case 2: { + if (LIKELY(_readState.fieldType == apache::thrift::protocol::T_I32)) { + goto _readField_latency_in_us; + } else { + goto _skip; + } + } + case 3: { + if (LIKELY(_readState.fieldType == apache::thrift::protocol::T_STRUCT)) { + goto _readField_data; + } else { + goto _skip; + } + } + case 4: { + if (LIKELY(_readState.fieldType == apache::thrift::protocol::T_STRING)) { + goto _readField_space_name; + } else { + goto _skip; + } + } + case 5: { + if (LIKELY(_readState.fieldType == apache::thrift::protocol::T_STRING)) { + goto _readField_error_msg; + } else { + goto _skip; + } + } + case 6: { + if (LIKELY(_readState.fieldType == apache::thrift::protocol::T_STRUCT)) { + goto _readField_plan_desc; + } else { + goto _skip; + } + } + case 7: { + if (LIKELY(_readState.fieldType == apache::thrift::protocol::T_STRING)) { + goto _readField_comment; + } else { + goto _skip; + } + } + default: { + _skip: + proto->skip(_readState.fieldType); + _readState.readFieldEnd(proto); + _readState.readFieldBeginNoInline(proto); + goto _loop; + } + } +} + +template +uint32_t Cpp2Ops<::nebula::ExecutionResponse>::serializedSize( + Protocol const* proto, + ::nebula::ExecutionResponse const* obj) { + uint32_t xfer = 0; + xfer += proto->serializedStructSize("ExecutionResponse"); + xfer += proto->serializedFieldSize("error_code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< + ::apache::thrift::type_class::enumeration, + ::nebula::ErrorCode>::serializedSize(*proto, obj->errorCode); + xfer += proto->serializedFieldSize("latency_in_us", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm:: + protocol_methods<::apache::thrift::type_class::integral, int32_t>::serializedSize( + *proto, obj->latencyInUs); + if (obj->data != nullptr) { + xfer += proto->serializedFieldSize("data", apache::thrift::protocol::T_STRUCT, 3); + xfer += ::apache::thrift::Cpp2Ops::serializedSize(proto, obj->data.get()); + } + if (obj->spaceName != nullptr) { + xfer += proto->serializedFieldSize("space_name", apache::thrift::protocol::T_STRING, 4); + xfer += proto->serializedSizeBinary(obj->spaceName); + } + if (obj->errorMsg != nullptr) { + xfer += proto->serializedFieldSize("error_msg", apache::thrift::protocol::T_STRING, 5); + xfer += proto->serializedSizeBinary(obj->errorMsg); + } + if (obj->planDesc != nullptr) { + xfer += proto->serializedFieldSize("plan_desc", apache::thrift::protocol::T_STRUCT, 6); + xfer += ::apache::thrift::Cpp2Ops<::nebula::PlanDescription>::serializedSize( + proto, obj->planDesc.get()); + } + if (obj->comment != nullptr) { + xfer += proto->serializedFieldSize("comment", apache::thrift::protocol::T_STRING, 7); + xfer += proto->serializedSizeBinary(obj->comment); + } + xfer += proto->serializedSizeStop(); + return xfer; +} + +template +uint32_t Cpp2Ops<::nebula::ExecutionResponse>::serializedSizeZC( + Protocol const* proto, + ::nebula::ExecutionResponse const* obj) { + uint32_t xfer = 0; + xfer += proto->serializedStructSize("ExecutionResponse"); + xfer += proto->serializedFieldSize("error_code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< + ::apache::thrift::type_class::enumeration, + ::nebula::ErrorCode>::serializedSize(*proto, obj->errorCode); + xfer += proto->serializedFieldSize("latency_in_us", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm:: + protocol_methods<::apache::thrift::type_class::integral, int32_t>::serializedSize( + *proto, obj->latencyInUs); + if (obj->data != nullptr) { + xfer += proto->serializedFieldSize("data", apache::thrift::protocol::T_STRUCT, 3); + xfer += + ::apache::thrift::Cpp2Ops::serializedSizeZC(proto, obj->data.get()); + } + if (obj->spaceName != nullptr) { + xfer += proto->serializedFieldSize("space_name", apache::thrift::protocol::T_STRING, 4); + xfer += proto->serializedSizeZCBinary(*obj->spaceName); + } + if (obj->errorMsg != nullptr) { + xfer += proto->serializedFieldSize("error_msg", apache::thrift::protocol::T_STRING, 5); + xfer += proto->serializedSizeZCBinary(*obj->errorMsg); + } + if (obj->planDesc != nullptr) { + xfer += proto->serializedFieldSize("plan_desc", apache::thrift::protocol::T_STRUCT, 6); + xfer += ::apache::thrift::Cpp2Ops<::nebula::PlanDescription>::serializedSizeZC( + proto, obj->planDesc.get()); + } + if (obj->comment != nullptr) { + xfer += proto->serializedFieldSize("comment", apache::thrift::protocol::T_STRING, 7); + xfer += proto->serializedSizeZCBinary(*obj->comment); + } + xfer += proto->serializedSizeStop(); + return xfer; +} + +} // namespace thrift +} // namespace apache diff --git a/include/common/graph/GraphCpp2Ops.h b/include/common/graph/GraphCpp2Ops.h new file mode 100644 index 00000000..1c461b12 --- /dev/null +++ b/include/common/graph/GraphCpp2Ops.h @@ -0,0 +1,31 @@ +/* Copyright (c) 2021 vesoft inc. All rights reserved. + * + * This source code is licensed under Apache 2.0 License, + * attached with Common Clause Condition 1.0, found in the LICENSES directory. + */ + +#pragma once + +#include "common/thrift/ThriftCpp2OpsHelper.h" + +namespace nebula { +struct AuthResponse; +struct ExecutionResponse; +struct Pair; +struct PlanDescription; +struct PlanNodeBranchInfo; +struct PlanNodeDescription; +struct ProfilingStats; +} // namespace nebula + +namespace apache::thrift { + +SPECIALIZE_CPP2OPS(nebula::AuthResponse); +SPECIALIZE_CPP2OPS(nebula::ExecutionResponse); +SPECIALIZE_CPP2OPS(nebula::Pair); +SPECIALIZE_CPP2OPS(nebula::PlanDescription); +SPECIALIZE_CPP2OPS(nebula::PlanNodeBranchInfo); +SPECIALIZE_CPP2OPS(nebula::PlanNodeDescription); +SPECIALIZE_CPP2OPS(nebula::ProfilingStats); + +} // namespace apache::thrift diff --git a/include/common/graph/PairOps-inl.h b/include/common/graph/PairOps-inl.h new file mode 100644 index 00000000..e488ae02 --- /dev/null +++ b/include/common/graph/PairOps-inl.h @@ -0,0 +1,166 @@ +/* Copyright (c) 2020 vesoft inc. All rights reserved. + * + * This source code is licensed under Apache 2.0 License, + * attached with Common Clause Condition 1.0, found in the LICENSES directory. + */ + +#pragma once + +#include +#include +#include + +#include "common/graph/GraphCpp2Ops.h" +#include "common/graph/Response.h" +#include "common/utils/utils.h" + +namespace apache { +namespace thrift { + +/************************************** + * + * Ops for class ProfilingStatsOps + * + *************************************/ +namespace detail { + +template <> +struct TccStructTraits { + static void translateFieldName(MAYBE_UNUSED folly::StringPiece _fname, + MAYBE_UNUSED int16_t& fid, + MAYBE_UNUSED apache::thrift::protocol::TType& _ftype) { + if (false) { + } else if (_fname == "key") { + fid = 1; + _ftype = apache::thrift::protocol::T_STRING; + } else if (_fname == "value") { + fid = 2; + _ftype = apache::thrift::protocol::T_STRING; + } + } +}; + +} // namespace detail + +inline constexpr apache::thrift::protocol::TType Cpp2Ops<::nebula::Pair>::thriftType() { + return apache::thrift::protocol::T_STRUCT; +} + +template +uint32_t Cpp2Ops<::nebula::Pair>::write(Protocol* proto, ::nebula::Pair const* obj) { + uint32_t xfer = 0; + xfer += proto->writeStructBegin("Pair"); + xfer += proto->writeFieldBegin("key", apache::thrift::protocol::T_STRING, 1); + xfer += proto->writeBinary(obj->key); + xfer += proto->writeFieldEnd(); + xfer += proto->writeFieldBegin("value", apache::thrift::protocol::T_STRING, 2); + xfer += proto->writeBinary(obj->value); + xfer += proto->writeFieldEnd(); + xfer += proto->writeFieldStop(); + xfer += proto->writeStructEnd(); + return xfer; +} + +template +void Cpp2Ops<::nebula::Pair>::read(Protocol* proto, ::nebula::Pair* obj) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(proto); + + using apache::thrift::TProtocolException; + + bool isset_key = false; + bool isset_value = false; + + if (UNLIKELY(!_readState.advanceToNextField(proto, 0, 1, apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_key : { + proto->readBinary(obj->key); + isset_key = true; +} + + if (UNLIKELY(!_readState.advanceToNextField(proto, 1, 2, apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_value : { + proto->readBinary(obj->value); + isset_value = true; +} + + if (UNLIKELY(!_readState.advanceToNextField(proto, 2, 0, apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(proto); + + if (!isset_key) { + TProtocolException::throwMissingRequiredField("key", "Pair"); + } + if (!isset_value) { + TProtocolException::throwMissingRequiredField("value", "Pair"); + } + return; + +_loop: + if (_readState.fieldType == apache::thrift::protocol::T_STOP) { + goto _end; + } + if (proto->kUsesFieldNames()) { + apache::thrift::detail::TccStructTraits::translateFieldName( + _readState.fieldName(), _readState.fieldId, _readState.fieldType); + } + + switch (_readState.fieldId) { + case 1: { + if (LIKELY(_readState.fieldType == apache::thrift::protocol::T_STRING)) { + goto _readField_key; + } else { + goto _skip; + } + } + case 2: { + if (LIKELY(_readState.fieldType == apache::thrift::protocol::T_STRING)) { + goto _readField_value; + } else { + goto _skip; + } + } + default: { + _skip: + proto->skip(_readState.fieldType); + _readState.readFieldEnd(proto); + _readState.readFieldBeginNoInline(proto); + goto _loop; + } + } +} + +template +uint32_t Cpp2Ops<::nebula::Pair>::serializedSize(Protocol const* proto, ::nebula::Pair const* obj) { + uint32_t xfer = 0; + xfer += proto->serializedStructSize("Pair"); + xfer += proto->serializedFieldSize("key", apache::thrift::protocol::T_STRING, 1); + xfer += proto->serializedSizeBinary(obj->key); + xfer += proto->serializedFieldSize("value", apache::thrift::protocol::T_STRING, 2); + xfer += proto->serializedSizeBinary(obj->value); + xfer += proto->serializedSizeStop(); + return xfer; +} + +template +uint32_t Cpp2Ops<::nebula::Pair>::serializedSizeZC(Protocol const* proto, + ::nebula::Pair const* obj) { + uint32_t xfer = 0; + xfer += proto->serializedStructSize("Pair"); + xfer += proto->serializedFieldSize("key", apache::thrift::protocol::T_STRING, 1); + xfer += proto->serializedSizeZCBinary(obj->key); + xfer += proto->serializedFieldSize("value", apache::thrift::protocol::T_STRING, 2); + xfer += proto->serializedSizeZCBinary(obj->value); + xfer += proto->serializedSizeStop(); + return xfer; +} + +} // namespace thrift +} // namespace apache diff --git a/include/common/graph/PlanDescriptionOps-inl.h b/include/common/graph/PlanDescriptionOps-inl.h new file mode 100644 index 00000000..f7987ae3 --- /dev/null +++ b/include/common/graph/PlanDescriptionOps-inl.h @@ -0,0 +1,259 @@ +/* Copyright (c) 2020 vesoft inc. All rights reserved. + * + * This source code is licensed under Apache 2.0 License, + * attached with Common Clause Condition 1.0, found in the LICENSES directory. + */ + +#pragma once + +#include +#include +#include + +#include "common/graph/GraphCpp2Ops.h" +#include "common/graph/Response.h" +#include "common/utils/utils.h" + +namespace apache { +namespace thrift { + +/************************************** + * + * Ops for class ProfilingStatsOps + * + *************************************/ +namespace detail { + +template <> +struct TccStructTraits<::nebula::PlanDescription> { + static void translateFieldName(MAYBE_UNUSED folly::StringPiece _fname, + MAYBE_UNUSED int16_t& fid, + MAYBE_UNUSED apache::thrift::protocol::TType& _ftype) { + if (false) { + } else if (_fname == "plan_node_descs") { + fid = 1; + _ftype = apache::thrift::protocol::T_LIST; + } else if (_fname == "node_index_map") { + fid = 2; + _ftype = apache::thrift::protocol::T_MAP; + } else if (_fname == "format") { + fid = 3; + _ftype = apache::thrift::protocol::T_STRING; + } else if (_fname == "optimize_time_in_us") { + fid = 4; + _ftype = apache::thrift::protocol::T_I32; + } + } +}; + +} // namespace detail + +inline constexpr apache::thrift::protocol::TType Cpp2Ops<::nebula::PlanDescription>::thriftType() { + return apache::thrift::protocol::T_STRUCT; +} + +template +uint32_t Cpp2Ops<::nebula::PlanDescription>::write(Protocol* proto, + ::nebula::PlanDescription const* obj) { + uint32_t xfer = 0; + xfer += proto->writeStructBegin("PlanDescription"); + xfer += proto->writeFieldBegin("plan_node_descs", apache::thrift::protocol::T_LIST, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + std::vector<::nebula::PlanNodeDescription>>::write(*proto, obj->planNodeDescs); + xfer += proto->writeFieldEnd(); + xfer += proto->writeFieldBegin("node_index_map", apache::thrift::protocol::T_MAP, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< + ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, + ::apache::thrift::type_class::integral>, + std::unordered_map>::write(*proto, obj->nodeIndexMap); + xfer += proto->writeFieldEnd(); + xfer += proto->writeFieldBegin("format", apache::thrift::protocol::T_STRING, 3); + xfer += proto->writeBinary(obj->format); + xfer += proto->writeFieldEnd(); + xfer += proto->writeFieldBegin("optimize_time_in_us", apache::thrift::protocol::T_I32, 4); + xfer += + ::apache::thrift::detail::pm::protocol_methods<::apache::thrift::type_class::integral, + int32_t>::write(*proto, + obj->optimize_time_in_us); + xfer += proto->writeFieldEnd(); + xfer += proto->writeFieldStop(); + xfer += proto->writeStructEnd(); + return xfer; +} + +template +void Cpp2Ops<::nebula::PlanDescription>::read(Protocol* proto, ::nebula::PlanDescription* obj) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(proto); + + using apache::thrift::TProtocolException; + + bool isset_plan_node_descs = false; + bool isset_node_index_map = false; + bool isset_format = false; + bool isset_optimize_time_in_us = false; + + if (UNLIKELY(!_readState.advanceToNextField(proto, 0, 1, apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_plan_node_descs : { + obj->planNodeDescs = std::vector<::nebula::PlanNodeDescription>(); + ::apache::thrift::detail::pm::protocol_methods< + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + std::vector<::nebula::PlanNodeDescription>>::read(*proto, obj->planNodeDescs); + isset_plan_node_descs = true; +} + + if (UNLIKELY(!_readState.advanceToNextField(proto, 1, 2, apache::thrift::protocol::T_MAP))) { + goto _loop; + } +_readField_node_index_map : { + obj->nodeIndexMap = std::unordered_map(); + ::apache::thrift::detail::pm::protocol_methods< + ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, + ::apache::thrift::type_class::integral>, + std::unordered_map>::read(*proto, obj->nodeIndexMap); + isset_node_index_map = true; +} + + if (UNLIKELY(!_readState.advanceToNextField(proto, 2, 3, apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_format : { + proto->readBinary(obj->format); + isset_format = true; +} + + if (UNLIKELY(!_readState.advanceToNextField(proto, 3, 4, apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_optimize_in_us : { + ::apache::thrift::detail::pm::protocol_methods<::apache::thrift::type_class::integral, + int32_t>::read(*proto, obj->optimize_time_in_us); + isset_optimize_time_in_us = true; +} + + if (UNLIKELY(!_readState.advanceToNextField(proto, 4, 0, apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(proto); + + if (!isset_plan_node_descs) { + TProtocolException::throwMissingRequiredField("plan_node_descs", "PlanDescription"); + } + if (!isset_node_index_map) { + TProtocolException::throwMissingRequiredField("node_index_map", "PlanDescription"); + } + if (!isset_format) { + TProtocolException::throwMissingRequiredField("format", "PlanDescription"); + } + if (!isset_optimize_time_in_us) { + TProtocolException::throwMissingRequiredField("optimize_time_in_us", "PlanDescription"); + } + return; + +_loop: + if (_readState.fieldType == apache::thrift::protocol::T_STOP) { + goto _end; + } + if (proto->kUsesFieldNames()) { + apache::thrift::detail::TccStructTraits::translateFieldName( + _readState.fieldName(), _readState.fieldId, _readState.fieldType); + } + + switch (_readState.fieldId) { + case 1: { + if (LIKELY(_readState.fieldType == apache::thrift::protocol::T_LIST)) { + goto _readField_plan_node_descs; + } else { + goto _skip; + } + } + case 2: { + if (LIKELY(_readState.fieldType == apache::thrift::protocol::T_MAP)) { + goto _readField_node_index_map; + } else { + goto _skip; + } + } + case 3: { + if (LIKELY(_readState.fieldType == apache::thrift::protocol::T_STRING)) { + goto _readField_format; + } else { + goto _skip; + } + } + case 4: { + if (LIKELY(_readState.fieldType == apache::thrift::protocol::T_I32)) { + goto _readField_optimize_in_us; + } else { + goto _skip; + } + } + default: { + _skip: + proto->skip(_readState.fieldType); + _readState.readFieldEnd(proto); + _readState.readFieldBeginNoInline(proto); + goto _loop; + } + } +} + +template +uint32_t Cpp2Ops<::nebula::PlanDescription>::serializedSize(Protocol const* proto, + ::nebula::PlanDescription const* obj) { + uint32_t xfer = 0; + xfer += proto->serializedStructSize("PlanDescription"); + xfer += proto->serializedFieldSize("plan_node_descs", apache::thrift::protocol::T_LIST, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + std::vector<::nebula::PlanNodeDescription>>::serializedSize(*proto, + obj->planNodeDescs); + xfer += proto->serializedFieldSize("node_index_map", apache::thrift::protocol::T_MAP, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< + ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, + ::apache::thrift::type_class::integral>, + std::unordered_map>::serializedSize(*proto, obj->nodeIndexMap); + xfer += proto->serializedFieldSize("format", apache::thrift::protocol::T_STRING, 3); + xfer += proto->serializedSizeBinary(obj->format); + xfer += proto->serializedFieldSize("optimize_time_in_us", apache::thrift::protocol::T_I32, 4); + xfer += ::apache::thrift::detail::pm:: + protocol_methods<::apache::thrift::type_class::integral, int32_t>::serializedSize( + *proto, obj->optimize_time_in_us); + xfer += proto->serializedSizeStop(); + return xfer; +} + +template +uint32_t Cpp2Ops<::nebula::PlanDescription>::serializedSizeZC( + Protocol const* proto, + ::nebula::PlanDescription const* obj) { + uint32_t xfer = 0; + xfer += proto->serializedStructSize("PlanDescription"); + xfer += proto->serializedFieldSize("plan_node_descs", apache::thrift::protocol::T_LIST, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + std::vector<::nebula::PlanNodeDescription>>::serializedSize(*proto, + obj->planNodeDescs); + xfer += proto->serializedFieldSize("node_index_map", apache::thrift::protocol::T_MAP, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< + ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, + ::apache::thrift::type_class::integral>, + std::unordered_map>::serializedSize(*proto, obj->nodeIndexMap); + xfer += proto->serializedFieldSize("format", apache::thrift::protocol::T_STRING, 3); + xfer += proto->serializedSizeZCBinary(obj->format); + xfer += proto->serializedFieldSize("optimize_time_in_us", apache::thrift::protocol::T_I32, 4); + xfer += ::apache::thrift::detail::pm:: + protocol_methods<::apache::thrift::type_class::integral, int32_t>::serializedSize( + *proto, obj->optimize_time_in_us); + xfer += proto->serializedSizeStop(); + return xfer; +} + +} // namespace thrift +} // namespace apache diff --git a/include/common/graph/PlanNodeBranchInfoOps-inl.h b/include/common/graph/PlanNodeBranchInfoOps-inl.h new file mode 100644 index 00000000..8ce7af55 --- /dev/null +++ b/include/common/graph/PlanNodeBranchInfoOps-inl.h @@ -0,0 +1,180 @@ +/* Copyright (c) 2020 vesoft inc. All rights reserved. + * + * This source code is licensed under Apache 2.0 License, + * attached with Common Clause Condition 1.0, found in the LICENSES directory. + */ + +#pragma once + +#include +#include +#include + +#include "common/graph/GraphCpp2Ops.h" +#include "common/graph/Response.h" +#include "common/utils/utils.h" + +namespace apache { +namespace thrift { + +/************************************** + * + * Ops for class nebula::PlanNodeBranchInfo + * + *************************************/ +namespace detail { + +template <> +struct TccStructTraits { + static void translateFieldName(MAYBE_UNUSED folly::StringPiece _fname, + MAYBE_UNUSED int16_t& fid, + MAYBE_UNUSED apache::thrift::protocol::TType& _ftype) { + if (false) { + } else if (_fname == "is_do_branch") { + fid = 1; + _ftype = apache::thrift::protocol::T_BOOL; + } else if (_fname == "condition_node_id") { + fid = 2; + _ftype = apache::thrift::protocol::T_I64; + } + } +}; + +} // namespace detail + +inline constexpr apache::thrift::protocol::TType +Cpp2Ops<::nebula::PlanNodeBranchInfo>::thriftType() { + return apache::thrift::protocol::T_STRUCT; +} + +template +uint32_t Cpp2Ops<::nebula::PlanNodeBranchInfo>::write(Protocol* proto, + ::nebula::PlanNodeBranchInfo const* obj) { + uint32_t xfer = 0; + xfer += proto->writeStructBegin("nebula::PlanNodeBranchInfo"); + xfer += proto->writeFieldBegin("is_do_branch", apache::thrift::protocol::T_BOOL, 1); + xfer += proto->writeBool(obj->isDoBranch); + xfer += proto->writeFieldEnd(); + xfer += proto->writeFieldBegin("condition_node_id", apache::thrift::protocol::T_I64, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods<::apache::thrift::type_class::integral, + int64_t>::write(*proto, + obj->conditionNodeId); + xfer += proto->writeFieldEnd(); + xfer += proto->writeFieldStop(); + xfer += proto->writeStructEnd(); + return xfer; +} + +template +void Cpp2Ops<::nebula::PlanNodeBranchInfo>::read(Protocol* proto, + ::nebula::PlanNodeBranchInfo* obj) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(proto); + + using apache::thrift::TProtocolException; + + bool isset_is_do_branch = false; + bool isset_condition_node_id = false; + + if (UNLIKELY(!_readState.advanceToNextField(proto, 0, 1, apache::thrift::protocol::T_BOOL))) { + goto _loop; + } +_readField_is_do_branch : { + proto->readBool(obj->isDoBranch); + isset_is_do_branch = true; +} + + if (UNLIKELY(!_readState.advanceToNextField(proto, 1, 2, apache::thrift::protocol::T_I64))) { + goto _loop; + } +_readField_condition_node_id : { + ::apache::thrift::detail::pm::protocol_methods<::apache::thrift::type_class::integral, + int64_t>::read(*proto, obj->conditionNodeId); + isset_condition_node_id = true; +} + + if (UNLIKELY(!_readState.advanceToNextField(proto, 2, 0, apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(proto); + + if (!isset_is_do_branch) { + TProtocolException::throwMissingRequiredField("is_do_branch", "nebula::PlanNodeBranchInfo"); + } + if (!isset_condition_node_id) { + TProtocolException::throwMissingRequiredField("condition_node_id", + "nebula::PlanNodeBranchInfo"); + } + return; + +_loop: + if (_readState.fieldType == apache::thrift::protocol::T_STOP) { + goto _end; + } + if (proto->kUsesFieldNames()) { + apache::thrift::detail::TccStructTraits::translateFieldName( + _readState.fieldName(), _readState.fieldId, _readState.fieldType); + } + + switch (_readState.fieldId) { + case 1: { + if (LIKELY(_readState.fieldType == apache::thrift::protocol::T_BOOL)) { + goto _readField_is_do_branch; + } else { + goto _skip; + } + } + case 2: { + if (LIKELY(_readState.fieldType == apache::thrift::protocol::T_I64)) { + goto _readField_condition_node_id; + } else { + goto _skip; + } + } + default: { + _skip: + proto->skip(_readState.fieldType); + _readState.readFieldEnd(proto); + _readState.readFieldBeginNoInline(proto); + goto _loop; + } + } +} + +template +uint32_t Cpp2Ops<::nebula::PlanNodeBranchInfo>::serializedSize( + Protocol const* proto, + ::nebula::PlanNodeBranchInfo const* obj) { + uint32_t xfer = 0; + xfer += proto->serializedStructSize("nebula::PlanNodeBranchInfo"); + xfer += proto->serializedFieldSize("is_do_branch", apache::thrift::protocol::T_BOOL, 1); + xfer += proto->serializedSizeBool(obj->isDoBranch); + xfer += proto->serializedFieldSize("condition_node_id", apache::thrift::protocol::T_I64, 2); + xfer += ::apache::thrift::detail::pm:: + protocol_methods<::apache::thrift::type_class::integral, int64_t>::serializedSize( + *proto, obj->conditionNodeId); + xfer += proto->serializedSizeStop(); + return xfer; +} + +template +uint32_t Cpp2Ops<::nebula::PlanNodeBranchInfo>::serializedSizeZC( + Protocol const* proto, + ::nebula::PlanNodeBranchInfo const* obj) { + uint32_t xfer = 0; + xfer += proto->serializedStructSize("nebula::PlanNodeBranchInfo"); + xfer += proto->serializedFieldSize("is_do_branch", apache::thrift::protocol::T_BOOL, 1); + xfer += proto->serializedSizeBool(obj->isDoBranch); + xfer += proto->serializedFieldSize("condition_node_id", apache::thrift::protocol::T_I64, 2); + xfer += ::apache::thrift::detail::pm:: + protocol_methods<::apache::thrift::type_class::integral, int64_t>::serializedSize( + *proto, obj->conditionNodeId); + xfer += proto->serializedSizeStop(); + return xfer; +} + +} // namespace thrift +} // namespace apache diff --git a/include/common/graph/PlanNodeDescriptionOps-inl.h b/include/common/graph/PlanNodeDescriptionOps-inl.h new file mode 100644 index 00000000..e9802978 --- /dev/null +++ b/include/common/graph/PlanNodeDescriptionOps-inl.h @@ -0,0 +1,364 @@ +/* Copyright (c) 2020 vesoft inc. All rights reserved. + * + * This source code is licensed under Apache 2.0 License, + * attached with Common Clause Condition 1.0, found in the LICENSES directory. + */ + +#pragma once + +#include +#include +#include + +#include + +#include "common/graph/GraphCpp2Ops.h" +#include "common/graph/Response.h" +#include "common/utils/utils.h" + +namespace apache { +namespace thrift { + +/************************************** + * + * Ops for class PlanNodeDescription + * + *************************************/ +namespace detail { + +template <> +struct TccStructTraits<::nebula::PlanNodeDescription> { + static void translateFieldName(MAYBE_UNUSED folly::StringPiece _fname, + MAYBE_UNUSED int16_t& fid, + MAYBE_UNUSED apache::thrift::protocol::TType& _ftype) { + if (false) { + } else if (_fname == "name") { + fid = 1; + _ftype = apache::thrift::protocol::T_STRING; + } else if (_fname == "id") { + fid = 2; + _ftype = apache::thrift::protocol::T_I64; + } else if (_fname == "output_var") { + fid = 3; + _ftype = apache::thrift::protocol::T_STRING; + } else if (_fname == "description") { + fid = 4; + _ftype = apache::thrift::protocol::T_LIST; + } else if (_fname == "profiles") { + fid = 5; + _ftype = apache::thrift::protocol::T_LIST; + } else if (_fname == "branch_info") { + fid = 6; + _ftype = apache::thrift::protocol::T_STRUCT; + } else if (_fname == "dependencies") { + fid = 7; + _ftype = apache::thrift::protocol::T_LIST; + } + } +}; + +} // namespace detail + +inline constexpr apache::thrift::protocol::TType +Cpp2Ops<::nebula::PlanNodeDescription>::thriftType() { + return apache::thrift::protocol::T_STRUCT; +} + +template +uint32_t Cpp2Ops<::nebula::PlanNodeDescription>::write(Protocol* proto, + ::nebula::PlanNodeDescription const* obj) { + uint32_t xfer = 0; + xfer += proto->writeStructBegin("PlanNodeDescription"); + xfer += proto->writeFieldBegin("name", apache::thrift::protocol::T_STRING, 1); + xfer += proto->writeBinary(obj->name); + xfer += proto->writeFieldEnd(); + xfer += proto->writeFieldBegin("id", apache::thrift::protocol::T_I64, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods<::apache::thrift::type_class::integral, + int64_t>::write(*proto, obj->id); + xfer += proto->writeFieldEnd(); + xfer += proto->writeFieldBegin("output_var", apache::thrift::protocol::T_STRING, 3); + xfer += proto->writeBinary(obj->outputVar); + xfer += proto->writeFieldEnd(); + if (obj->description != nullptr) { + xfer += proto->writeFieldBegin("description", apache::thrift::protocol::T_LIST, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + std::vector<::nebula::Pair>>::write(*proto, *obj->description); + xfer += proto->writeFieldEnd(); + } + if (obj->profiles != nullptr) { + xfer += proto->writeFieldBegin("profiles", apache::thrift::protocol::T_LIST, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + std::vector<::nebula::ProfilingStats>>::write(*proto, *obj->profiles); + xfer += proto->writeFieldEnd(); + } + if (obj->branchInfo != nullptr) { + xfer += proto->writeFieldBegin("branch_info", apache::thrift::protocol::T_STRUCT, 6); + xfer += ::apache::thrift::Cpp2Ops<::nebula::PlanNodeBranchInfo>::write( + proto, obj->branchInfo.get()); + xfer += proto->writeFieldEnd(); + } + if (obj->dependencies != nullptr) { + xfer += proto->writeFieldBegin("dependencies", apache::thrift::protocol::T_LIST, 7); + xfer += ::apache::thrift::detail::pm::protocol_methods< + ::apache::thrift::type_class::list<::apache::thrift::type_class::integral>, + std::vector>::write(*proto, *obj->dependencies); + xfer += proto->writeFieldEnd(); + } + xfer += proto->writeFieldStop(); + xfer += proto->writeStructEnd(); + return xfer; +} + +template +void Cpp2Ops<::nebula::PlanNodeDescription>::read(Protocol* proto, + ::nebula::PlanNodeDescription* obj) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(proto); + + using apache::thrift::TProtocolException; + + bool isset_name = false; + bool isset_id = false; + bool isset_output_var = false; + + if (UNLIKELY(!_readState.advanceToNextField(proto, 0, 1, apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_name : { + proto->readBinary(obj->name); + isset_name = true; +} + + if (UNLIKELY(!_readState.advanceToNextField(proto, 1, 2, apache::thrift::protocol::T_I64))) { + goto _loop; + } +_readField_id : { + ::apache::thrift::detail::pm::protocol_methods<::apache::thrift::type_class::integral, + int64_t>::read(*proto, obj->id); + isset_id = true; +} + + if (UNLIKELY(!_readState.advanceToNextField(proto, 2, 3, apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_output_var : { + proto->readBinary(obj->outputVar); + isset_output_var = true; +} + + if (UNLIKELY(!_readState.advanceToNextField(proto, 3, 4, apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_description : { + obj->description = std::make_unique>(); + ::apache::thrift::detail::pm::protocol_methods< + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + std::vector<::nebula::Pair>>::read(*proto, *obj->description); + // this->__isset.description = true; +} + + if (UNLIKELY(!_readState.advanceToNextField(proto, 4, 5, apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_profiles : { + obj->profiles = std::make_unique>(); + ::apache::thrift::detail::pm::protocol_methods< + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + std::vector<::nebula::ProfilingStats>>::read(*proto, *obj->profiles); + // this->__isset.profiles = true; +} + + if (UNLIKELY(!_readState.advanceToNextField(proto, 5, 6, apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_branch_info : { + obj->branchInfo = std::make_unique(); + ::apache::thrift::Cpp2Ops<::nebula::PlanNodeBranchInfo>::read(proto, obj->branchInfo.get()); + // this->__isset.branch_info = true; +} + + if (UNLIKELY(!_readState.advanceToNextField(proto, 6, 7, apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_dependencies : { + obj->dependencies = std::make_unique>(); + ::apache::thrift::detail::pm::protocol_methods< + ::apache::thrift::type_class::list<::apache::thrift::type_class::integral>, + std::vector>::read(*proto, *obj->dependencies); + // this->__isset.dependencies = true; +} + + if (UNLIKELY(!_readState.advanceToNextField(proto, 7, 0, apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(proto); + + if (!isset_name) { + TProtocolException::throwMissingRequiredField("name", "PlanNodeDescription"); + } + if (!isset_id) { + TProtocolException::throwMissingRequiredField("id", "PlanNodeDescription"); + } + if (!isset_output_var) { + TProtocolException::throwMissingRequiredField("output_var", "PlanNodeDescription"); + } + return; + +_loop: + if (_readState.fieldType == apache::thrift::protocol::T_STOP) { + goto _end; + } + if (proto->kUsesFieldNames()) { + apache::thrift::detail::TccStructTraits::translateFieldName( + _readState.fieldName(), _readState.fieldId, _readState.fieldType); + } + + switch (_readState.fieldId) { + case 1: { + if (LIKELY(_readState.fieldType == apache::thrift::protocol::T_STRING)) { + goto _readField_name; + } else { + goto _skip; + } + } + case 2: { + if (LIKELY(_readState.fieldType == apache::thrift::protocol::T_I64)) { + goto _readField_id; + } else { + goto _skip; + } + } + case 3: { + if (LIKELY(_readState.fieldType == apache::thrift::protocol::T_STRING)) { + goto _readField_output_var; + } else { + goto _skip; + } + } + case 4: { + if (LIKELY(_readState.fieldType == apache::thrift::protocol::T_LIST)) { + goto _readField_description; + } else { + goto _skip; + } + } + case 5: { + if (LIKELY(_readState.fieldType == apache::thrift::protocol::T_LIST)) { + goto _readField_profiles; + } else { + goto _skip; + } + } + case 6: { + if (LIKELY(_readState.fieldType == apache::thrift::protocol::T_STRUCT)) { + goto _readField_branch_info; + } else { + goto _skip; + } + } + case 7: { + if (LIKELY(_readState.fieldType == apache::thrift::protocol::T_LIST)) { + goto _readField_dependencies; + } else { + goto _skip; + } + } + default: { + _skip: + proto->skip(_readState.fieldType); + _readState.readFieldEnd(proto); + _readState.readFieldBeginNoInline(proto); + goto _loop; + } + } +} + +template +uint32_t Cpp2Ops<::nebula::PlanNodeDescription>::serializedSize( + Protocol const* proto, + ::nebula::PlanNodeDescription const* obj) { + uint32_t xfer = 0; + xfer += proto->serializedStructSize("PlanNodeDescription"); + xfer += proto->serializedFieldSize("name", apache::thrift::protocol::T_STRING, 1); + xfer += proto->serializedSizeBinary(obj->name); + xfer += proto->serializedFieldSize("id", apache::thrift::protocol::T_I64, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods<::apache::thrift::type_class::integral, + int64_t>::serializedSize(*proto, + obj->id); + xfer += proto->serializedFieldSize("output_var", apache::thrift::protocol::T_STRING, 3); + xfer += proto->serializedSizeBinary(obj->outputVar); + if (obj->description != nullptr) { + xfer += proto->serializedFieldSize("description", apache::thrift::protocol::T_LIST, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + std::vector<::nebula::Pair>>::serializedSize(*proto, *obj->description); + } + if (obj->profiles != nullptr) { + xfer += proto->serializedFieldSize("profiles", apache::thrift::protocol::T_LIST, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + std::vector<::nebula::ProfilingStats>>::serializedSize(*proto, *obj->profiles); + } + if (obj->branchInfo != nullptr) { + xfer += proto->serializedFieldSize("branch_info", apache::thrift::protocol::T_STRUCT, 6); + xfer += ::apache::thrift::Cpp2Ops<::nebula::PlanNodeBranchInfo>::serializedSize( + proto, obj->branchInfo.get()); + } + if (obj->dependencies != nullptr) { + xfer += proto->serializedFieldSize("dependencies", apache::thrift::protocol::T_LIST, 7); + xfer += ::apache::thrift::detail::pm::protocol_methods< + ::apache::thrift::type_class::list<::apache::thrift::type_class::integral>, + std::vector>::serializedSize(*proto, *obj->dependencies); + } + xfer += proto->serializedSizeStop(); + return xfer; +} + +template +uint32_t Cpp2Ops<::nebula::PlanNodeDescription>::serializedSizeZC( + Protocol const* proto, + ::nebula::PlanNodeDescription const* obj) { + uint32_t xfer = 0; + xfer += proto->serializedStructSize("PlanNodeDescription"); + xfer += proto->serializedFieldSize("name", apache::thrift::protocol::T_STRING, 1); + xfer += proto->serializedSizeZCBinary(obj->name); + xfer += proto->serializedFieldSize("id", apache::thrift::protocol::T_I64, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods<::apache::thrift::type_class::integral, + int64_t>::serializedSize(*proto, + obj->id); + xfer += proto->serializedFieldSize("output_var", apache::thrift::protocol::T_STRING, 3); + xfer += proto->serializedSizeZCBinary(obj->outputVar); + if (obj->description != nullptr) { + xfer += proto->serializedFieldSize("description", apache::thrift::protocol::T_LIST, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + std::vector<::nebula::Pair>>::serializedSize(*proto, *obj->description); + } + if (obj->profiles != nullptr) { + xfer += proto->serializedFieldSize("profiles", apache::thrift::protocol::T_LIST, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + std::vector<::nebula::ProfilingStats>>::serializedSize(*proto, *obj->profiles); + } + if (obj->branchInfo != nullptr) { + xfer += proto->serializedFieldSize("branch_info", apache::thrift::protocol::T_STRUCT, 6); + xfer += ::apache::thrift::Cpp2Ops<::nebula::PlanNodeBranchInfo>::serializedSizeZC( + proto, obj->branchInfo.get()); + } + if (obj->dependencies != nullptr) { + xfer += proto->serializedFieldSize("dependencies", apache::thrift::protocol::T_LIST, 7); + xfer += ::apache::thrift::detail::pm::protocol_methods< + ::apache::thrift::type_class::list<::apache::thrift::type_class::integral>, + std::vector>::serializedSize(*proto, *obj->dependencies); + } + xfer += proto->serializedSizeStop(); + return xfer; +} + +} // namespace thrift +} // namespace apache diff --git a/include/common/graph/ProfilingStatsOps-inl.h b/include/common/graph/ProfilingStatsOps-inl.h new file mode 100644 index 00000000..34afb256 --- /dev/null +++ b/include/common/graph/ProfilingStatsOps-inl.h @@ -0,0 +1,266 @@ +/* Copyright (c) 2020 vesoft inc. All rights reserved. + * + * This source code is licensed under Apache 2.0 License, + * attached with Common Clause Condition 1.0, found in the LICENSES directory. + */ + +#pragma once + +#include +#include +#include + +#include + +#include "common/graph/GraphCpp2Ops.h" +#include "common/graph/Response.h" +#include "common/utils/utils.h" + +namespace apache { +namespace thrift { + +/************************************** + * + * Ops for class ProfilingStatsOps + * + *************************************/ +namespace detail { + +template <> +struct TccStructTraits { + static void translateFieldName(MAYBE_UNUSED folly::StringPiece _fname, + MAYBE_UNUSED int16_t& fid, + MAYBE_UNUSED apache::thrift::protocol::TType& _ftype) { + if (false) { + } else if (_fname == "rows") { + fid = 1; + _ftype = apache::thrift::protocol::T_I64; + } else if (_fname == "exec_duration_in_us") { + fid = 2; + _ftype = apache::thrift::protocol::T_I64; + } else if (_fname == "total_duration_in_us") { + fid = 3; + _ftype = apache::thrift::protocol::T_I64; + } else if (_fname == "other_stats") { + fid = 4; + _ftype = apache::thrift::protocol::T_MAP; + } + } +}; +} // namespace detail + +inline constexpr apache::thrift::protocol::TType Cpp2Ops<::nebula::ProfilingStats>::thriftType() { + return apache::thrift::protocol::T_STRUCT; +} + +template +uint32_t Cpp2Ops<::nebula::ProfilingStats>::write(Protocol* proto, + ::nebula::ProfilingStats const* obj) { + uint32_t xfer = 0; + xfer += proto->writeStructBegin("ProfilingStats"); + xfer += proto->writeFieldBegin("rows", apache::thrift::protocol::T_I64, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods<::apache::thrift::type_class::integral, + int64_t>::write(*proto, obj->rows); + xfer += proto->writeFieldEnd(); + xfer += proto->writeFieldBegin("exec_duration_in_us", apache::thrift::protocol::T_I64, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods<::apache::thrift::type_class::integral, + int64_t>::write(*proto, + obj->execDurationInUs); + xfer += proto->writeFieldEnd(); + xfer += proto->writeFieldBegin("total_duration_in_us", apache::thrift::protocol::T_I64, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods<::apache::thrift::type_class::integral, + int64_t>::write(*proto, + obj->totalDurationInUs); + xfer += proto->writeFieldEnd(); + if (obj->otherStats != nullptr) { + xfer += proto->writeFieldBegin("other_stats", apache::thrift::protocol::T_MAP, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< + ::apache::thrift::type_class::map<::apache::thrift::type_class::binary, + ::apache::thrift::type_class::binary>, + std::unordered_map>::write(*proto, *obj->otherStats); + xfer += proto->writeFieldEnd(); + } + xfer += proto->writeFieldStop(); + xfer += proto->writeStructEnd(); + return xfer; +} + +template +void Cpp2Ops<::nebula::ProfilingStats>::read(Protocol* proto, ::nebula::ProfilingStats* obj) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(proto); + + using apache::thrift::TProtocolException; + + bool isset_rows = false; + bool isset_exec_duration_in_us = false; + bool isset_total_duration_in_us = false; + + if (UNLIKELY(!_readState.advanceToNextField(proto, 0, 1, apache::thrift::protocol::T_I64))) { + goto _loop; + } +_readField_rows : { + ::apache::thrift::detail::pm::protocol_methods<::apache::thrift::type_class::integral, + int64_t>::read(*proto, obj->rows); + isset_rows = true; +} + + if (UNLIKELY(!_readState.advanceToNextField(proto, 1, 2, apache::thrift::protocol::T_I64))) { + goto _loop; + } +_readField_exec_duration_in_us : { + ::apache::thrift::detail::pm::protocol_methods<::apache::thrift::type_class::integral, + int64_t>::read(*proto, obj->execDurationInUs); + isset_exec_duration_in_us = true; +} + + if (UNLIKELY(!_readState.advanceToNextField(proto, 2, 3, apache::thrift::protocol::T_I64))) { + goto _loop; + } +_readField_total_duration_in_us : { + ::apache::thrift::detail::pm::protocol_methods<::apache::thrift::type_class::integral, + int64_t>::read(*proto, obj->totalDurationInUs); + isset_total_duration_in_us = true; +} + + if (UNLIKELY(!_readState.advanceToNextField(proto, 3, 4, apache::thrift::protocol::T_MAP))) { + goto _loop; + } +_readField_other_stats : { + obj->otherStats = std::make_unique>(); + ::apache::thrift::detail::pm::protocol_methods< + ::apache::thrift::type_class::map<::apache::thrift::type_class::binary, + ::apache::thrift::type_class::binary>, + std::unordered_map>::read(*proto, *obj->otherStats); + // this->__isset.other_stats = true; +} + + if (UNLIKELY(!_readState.advanceToNextField(proto, 4, 0, apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(proto); + + if (!isset_rows) { + TProtocolException::throwMissingRequiredField("rows", "ProfilingStats"); + } + if (!isset_exec_duration_in_us) { + TProtocolException::throwMissingRequiredField("exec_duration_in_us", "ProfilingStats"); + } + if (!isset_total_duration_in_us) { + TProtocolException::throwMissingRequiredField("total_duration_in_us", "ProfilingStats"); + } + return; + +_loop: + if (_readState.fieldType == apache::thrift::protocol::T_STOP) { + goto _end; + } + if (proto->kUsesFieldNames()) { + apache::thrift::detail::TccStructTraits::translateFieldName( + _readState.fieldName(), _readState.fieldId, _readState.fieldType); + } + + switch (_readState.fieldId) { + case 1: { + if (LIKELY(_readState.fieldType == apache::thrift::protocol::T_I64)) { + goto _readField_rows; + } else { + goto _skip; + } + } + case 2: { + if (LIKELY(_readState.fieldType == apache::thrift::protocol::T_I64)) { + goto _readField_exec_duration_in_us; + } else { + goto _skip; + } + } + case 3: { + if (LIKELY(_readState.fieldType == apache::thrift::protocol::T_I64)) { + goto _readField_total_duration_in_us; + } else { + goto _skip; + } + } + case 4: { + if (LIKELY(_readState.fieldType == apache::thrift::protocol::T_MAP)) { + goto _readField_other_stats; + } else { + goto _skip; + } + } + default: { + _skip: + proto->skip(_readState.fieldType); + _readState.readFieldEnd(proto); + _readState.readFieldBeginNoInline(proto); + goto _loop; + } + } +} + +template +uint32_t Cpp2Ops<::nebula::ProfilingStats>::serializedSize(Protocol const* proto, + ::nebula::ProfilingStats const* obj) { + uint32_t xfer = 0; + xfer += proto->serializedStructSize("ProfilingStats"); + xfer += proto->serializedFieldSize("rows", apache::thrift::protocol::T_I64, 1); + xfer += + ::apache::thrift::detail::pm::protocol_methods<::apache::thrift::type_class::integral, + int64_t>::serializedSize(*proto, + obj->rows); + xfer += proto->serializedFieldSize("exec_duration_in_us", apache::thrift::protocol::T_I64, 2); + xfer += ::apache::thrift::detail::pm:: + protocol_methods<::apache::thrift::type_class::integral, int64_t>::serializedSize( + *proto, obj->execDurationInUs); + xfer += proto->serializedFieldSize("total_duration_in_us", apache::thrift::protocol::T_I64, 3); + xfer += ::apache::thrift::detail::pm:: + protocol_methods<::apache::thrift::type_class::integral, int64_t>::serializedSize( + *proto, obj->totalDurationInUs); + if (obj->otherStats != nullptr) { + xfer += proto->serializedFieldSize("other_stats", apache::thrift::protocol::T_MAP, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< + ::apache::thrift::type_class::map<::apache::thrift::type_class::binary, + ::apache::thrift::type_class::binary>, + std::unordered_map>::serializedSize(*proto, + *obj->otherStats); + } + xfer += proto->serializedSizeStop(); + return xfer; +} + +template +uint32_t Cpp2Ops<::nebula::ProfilingStats>::serializedSizeZC(Protocol const* proto, + ::nebula::ProfilingStats const* obj) { + uint32_t xfer = 0; + xfer += proto->serializedStructSize("ProfilingStats"); + xfer += proto->serializedFieldSize("rows", apache::thrift::protocol::T_I64, 1); + xfer += + ::apache::thrift::detail::pm::protocol_methods<::apache::thrift::type_class::integral, + int64_t>::serializedSize(*proto, + obj->rows); + xfer += proto->serializedFieldSize("exec_duration_in_us", apache::thrift::protocol::T_I64, 2); + xfer += ::apache::thrift::detail::pm:: + protocol_methods<::apache::thrift::type_class::integral, int64_t>::serializedSize( + *proto, obj->execDurationInUs); + xfer += proto->serializedFieldSize("total_duration_in_us", apache::thrift::protocol::T_I64, 3); + xfer += ::apache::thrift::detail::pm:: + protocol_methods<::apache::thrift::type_class::integral, int64_t>::serializedSize( + *proto, obj->totalDurationInUs); + if (obj->otherStats != nullptr) { + xfer += proto->serializedFieldSize("other_stats", apache::thrift::protocol::T_MAP, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< + ::apache::thrift::type_class::map<::apache::thrift::type_class::binary, + ::apache::thrift::type_class::binary>, + std::unordered_map>::serializedSize(*proto, + *obj->otherStats); + } + xfer += proto->serializedSizeStop(); + return xfer; +} + +} // namespace thrift +} // namespace apache diff --git a/include/common/graph/Response.h b/include/common/graph/Response.h new file mode 100644 index 00000000..95aa4a76 --- /dev/null +++ b/include/common/graph/Response.h @@ -0,0 +1,420 @@ +/* Copyright (c) 2020 vesoft inc. All rights reserved. + * + * This source code is licensed under Apache 2.0 License, + * attached with Common Clause Condition 1.0, found in the LICENSES directory. + */ + +#pragma once + +#include +#include +#include +#include +#include + +#include "common/datatypes/DataSet.h" + +#define ErrorCodeEnums \ + /* for common code */ \ + X(SUCCEEDED, 0) \ + \ + X(E_DISCONNECTED, -1) /* RPC Failure */ \ + X(E_FAIL_TO_CONNECT, -2) \ + X(E_RPC_FAILURE, -3) \ + X(E_LEADER_CHANGED, -4) \ + \ + /* only unify metad and storaged error code */ \ + X(E_SPACE_NOT_FOUND, -5) \ + X(E_TAG_NOT_FOUND, -6) \ + X(E_EDGE_NOT_FOUND, -7) \ + X(E_INDEX_NOT_FOUND, -8) \ + X(E_EDGE_PROP_NOT_FOUND, -9) \ + X(E_TAG_PROP_NOT_FOUND, -10) \ + X(E_ROLE_NOT_FOUND, -11) \ + X(E_CONFIG_NOT_FOUND, -12) \ + X(E_GROUP_NOT_FOUND, -13) \ + X(E_ZONE_NOT_FOUND, -14) \ + X(E_LISTENER_NOT_FOUND, -15) \ + X(E_PART_NOT_FOUND, -16) \ + X(E_KEY_NOT_FOUND, -17) \ + X(E_USER_NOT_FOUND, -18) \ + \ + /* backup failed */ \ + X(E_BACKUP_FAILED, -24) \ + X(E_BACKUP_EMPTY_TABLE, -25) \ + X(E_BACKUP_TABLE_FAILED, -26) \ + X(E_PARTIAL_RESULT, -27) \ + X(E_REBUILD_INDEX_FAILED, -28) \ + X(E_INVALID_PASSWORD, -29) \ + X(E_FAILED_GET_ABS_PATH, -30) \ + \ + /* 1xxx for graphd */ \ + X(E_BAD_USERNAME_PASSWORD, -1001) /* Authentication error */ \ + X(E_SESSION_INVALID, -1002) /* Execution errors */ \ + X(E_SESSION_TIMEOUT, -1003) \ + X(E_SYNTAX_ERROR, -1004) \ + X(E_EXECUTION_ERROR, -1005) \ + X(E_STATEMENT_EMPTY, -1006) /* Nothing is executed When command is empty */ \ + \ + X(E_BAD_PERMISSION, -1008) \ + X(E_SEMANTIC_ERROR, -1009) /* semantic error */ \ + X(E_TOO_MANY_CONNECTIONS, -1010) \ + X(E_PARTIAL_SUCCEEDED, -1011) \ + \ + /* 2xxx for metad */ \ + X(E_NO_HOSTS, -2001) /* Operation Failure*/ \ + X(E_EXISTED, -2002) \ + X(E_INVALID_HOST, -2003) \ + X(E_UNSUPPORTED, -2004) \ + X(E_NOT_DROP, -2005) \ + X(E_BALANCER_RUNNING, -2006) \ + X(E_CONFIG_IMMUTABLE, -2007) \ + X(E_CONFLICT, -2008) \ + X(E_INVALID_PARM, -2009) \ + X(E_WRONGCLUSTER, -2010) \ + \ + X(E_STORE_FAILURE, -2021) \ + X(E_STORE_SEGMENT_ILLEGAL, -2022) \ + X(E_BAD_BALANCE_PLAN, -2023) \ + X(E_BALANCED, -2024) \ + X(E_NO_RUNNING_BALANCE_PLAN, -2025) \ + X(E_NO_VALID_HOST, -2026) \ + X(E_CORRUPTTED_BALANCE_PLAN, -2027) \ + X(E_NO_INVALID_BALANCE_PLAN, -2028) \ + \ + /* Authentication Failure */ \ + X(E_IMPROPER_ROLE, -2030) \ + X(E_INVALID_PARTITION_NUM, -2031) \ + X(E_INVALID_REPLICA_FACTOR, -2032) \ + X(E_INVALID_CHARSET, -2033) \ + X(E_INVALID_COLLATE, -2034) \ + X(E_CHARSET_COLLATE_NOT_MATCH, -2035) \ + \ + /* Admin Failure */ \ + X(E_SNAPSHOT_FAILURE, -2040) \ + X(E_BLOCK_WRITE_FAILURE, -2041) \ + X(E_REBUILD_INDEX_FAILURE, -2042) \ + X(E_INDEX_WITH_TTL, -2043) \ + X(E_ADD_JOB_FAILURE, -2044) \ + X(E_STOP_JOB_FAILURE, -2045) \ + X(E_SAVE_JOB_FAILURE, -2046) \ + X(E_BALANCER_FAILURE, -2047) \ + X(E_JOB_NOT_FINISHED, -2048) \ + X(E_TASK_REPORT_OUT_DATE, -2049) \ + X(E_INVALID_JOB, -2065) \ + \ + /* Backup Failure */ \ + X(E_BACKUP_BUILDING_INDEX, -2066) \ + X(E_BACKUP_SPACE_NOT_FOUND, -2067) \ + \ + /* RESTORE Failure */ \ + X(E_RESTORE_FAILURE, -2068) \ + X(E_SESSION_NOT_FOUND, -2069) \ + \ + /* ListClusterInfo Failure */ \ + X(E_LIST_CLUSTER_FAILURE, -2070) \ + X(E_LIST_CLUSTER_GET_ABS_PATH_FAILURE, -2071) \ + X(E_GET_META_DIR_FAILURE, -2072) \ + \ + X(E_QUERY_NOT_FOUND, -2073) \ + /* 3xxx for storaged */ \ + X(E_CONSENSUS_ERROR, -3001) \ + X(E_KEY_HAS_EXISTS, -3002) \ + X(E_DATA_TYPE_MISMATCH, -3003) \ + X(E_INVALID_FIELD_VALUE, -3004) \ + X(E_INVALID_OPERATION, -3005) \ + X(E_NOT_NULLABLE, -3006) /* Not allowed to be null */ \ + /* The field neither can be NULL, nor has a default value */ \ + X(E_FIELD_UNSET, -3007) \ + /* Value exceeds the range of type */ \ + X(E_OUT_OF_RANGE, -3008) \ + /* Atomic operation failed */ \ + X(E_ATOMIC_OP_FAILED, -3009) \ + /* data conflict, for index write without toss. */ \ + X(E_DATA_CONFLICT_ERROR, -3010) \ + \ + X(E_WRITE_STALLED, -3011) \ + \ + /* meta failures */ \ + X(E_IMPROPER_DATA_TYPE, -3021) \ + X(E_INVALID_SPACEVIDLEN, -3022) \ + \ + /* Invalid request */ \ + X(E_INVALID_FILTER, -3031) \ + X(E_INVALID_UPDATER, -3032) \ + X(E_INVALID_STORE, -3033) \ + X(E_INVALID_PEER, -3034) \ + X(E_RETRY_EXHAUSTED, -3035) \ + X(E_TRANSFER_LEADER_FAILED, -3036) \ + X(E_INVALID_STAT_TYPE, -3037) \ + X(E_INVALID_VID, -3038) \ + X(E_NO_TRANSFORMED, -3039) \ + \ + /* meta client failed */ \ + X(E_LOAD_META_FAILED, -3040) \ + \ + /* checkpoint failed */ \ + X(E_FAILED_TO_CHECKPOINT, -3041) \ + X(E_CHECKPOINT_BLOCKED, -3042) \ + \ + /* Filter out */ \ + X(E_FILTER_OUT, -3043) \ + X(E_INVALID_DATA, -3044) \ + \ + X(E_MUTATE_EDGE_CONFLICT, -3045) \ + X(E_MUTATE_TAG_CONFLICT, -3046) \ + \ + /* transaction */ \ + X(E_OUTDATED_LOCK, -3047) \ + \ + /* task manager failed */ \ + X(E_INVALID_TASK_PARA, -3051) \ + X(E_USER_CANCEL, -3052) \ + X(E_TASK_EXECUTION_FAILED, -3053) \ + \ + X(E_PLAN_IS_KILLED, -3060) \ + X(E_CLIENT_SERVER_INCOMPATIBLE, -3061) \ + \ + X(E_UNKNOWN, -8000) + +namespace nebula { + +#define X(EnumName, EnumNumber) EnumName = EnumNumber, + +enum class ErrorCode { ErrorCodeEnums }; + +#undef X + +const char *getErrorCode(ErrorCode code); + +static inline std::ostream &operator<<(std::ostream &os, ErrorCode code) { + os << getErrorCode(code); + return os; +} + +template +bool inline checkPointer(const T *lhs, const T *rhs) { + if (lhs == rhs) { + return true; + } else if (lhs != nullptr && rhs != nullptr) { + return *lhs == *rhs; + } else { + return false; + } +} + +// TODO(shylock) use optional for optional in thrift instead of pointer + +struct AuthResponse { + void __clear() { + errorCode = ErrorCode::SUCCEEDED; + sessionId = nullptr; + errorMsg = nullptr; + } + + void clear() { + __clear(); + } + + bool operator==(const AuthResponse &rhs) const { + if (errorCode != rhs.errorCode) { + return false; + } + if (!checkPointer(sessionId.get(), rhs.sessionId.get())) { + return false; + } + if (!checkPointer(errorMsg.get(), rhs.errorMsg.get())) { + return false; + } + if (!checkPointer(timeZoneOffsetSeconds.get(), rhs.timeZoneOffsetSeconds.get())) { + return false; + } + return checkPointer(timeZoneName.get(), timeZoneName.get()); + } + + ErrorCode errorCode{ErrorCode::SUCCEEDED}; + std::unique_ptr sessionId{nullptr}; + std::unique_ptr errorMsg{nullptr}; + std::unique_ptr timeZoneOffsetSeconds{nullptr}; + std::unique_ptr timeZoneName{nullptr}; +}; + +struct ProfilingStats { + void __clear() { + rows = 0; + execDurationInUs = 0; + totalDurationInUs = 0; + otherStats = nullptr; + } + + void clear() { + __clear(); + } + + bool operator==(const ProfilingStats &rhs) const { + if (rows != rhs.rows) { + return false; + } + if (execDurationInUs != rhs.execDurationInUs) { + return false; + } + if (totalDurationInUs != rhs.totalDurationInUs) { + return false; + } + return checkPointer(otherStats.get(), rhs.otherStats.get()); + } + + // How many rows being processed in an executor. + int64_t rows{0}; + // Duration spent in an executor. + int64_t execDurationInUs{0}; + // Total duration spent in an executor, contains schedule time + int64_t totalDurationInUs{0}; + // Other profiling stats data map + std::unique_ptr> otherStats; +}; + +// The info used for select/loop. +struct PlanNodeBranchInfo { + void __clear() { + isDoBranch = false; + conditionNodeId = -1; + } + + void clear() { + __clear(); + } + + bool operator==(const PlanNodeBranchInfo &rhs) const { + return isDoBranch == rhs.isDoBranch && conditionNodeId == rhs.conditionNodeId; + } + + // True if loop body or then branch of select + bool isDoBranch{0}; + // select/loop node id + int64_t conditionNodeId{-1}; +}; + +struct Pair { + void __clear() { + key.clear(); + value.clear(); + } + + void clear() { + __clear(); + } + + bool operator==(const Pair &rhs) const { + return key == rhs.key && value == rhs.value; + } + + std::string key; + std::string value; +}; + +struct PlanNodeDescription { + void __clear() { + name.clear(); + id = -1; + outputVar.clear(); + description = nullptr; + profiles = nullptr; + branchInfo = nullptr; + dependencies = nullptr; + } + + void clear() { + __clear(); + } + + bool operator==(const PlanNodeDescription &rhs) const; + + std::string name; + int64_t id{-1}; + std::string outputVar; + // other description of an executor + std::unique_ptr> description{nullptr}; + // If an executor would be executed multi times, + // the profiling statistics should be multi-versioned. + std::unique_ptr> profiles{nullptr}; + std::unique_ptr branchInfo{nullptr}; + std::unique_ptr> dependencies{nullptr}; +}; + +struct PlanDescription { + void __clear() { + planNodeDescs.clear(); + nodeIndexMap.clear(); + format.clear(); + optimize_time_in_us = 0; + } + + void clear() { + __clear(); + } + + bool operator==(const PlanDescription &rhs) const { + return planNodeDescs == rhs.planNodeDescs && nodeIndexMap == rhs.nodeIndexMap && + format == rhs.format; + } + + std::vector planNodeDescs; + // map from node id to index of list + std::unordered_map nodeIndexMap; + // the print format of exec plan, lowercase string like `dot' + std::string format; + // the optimization spent time + int32_t optimize_time_in_us{0}; +}; + +struct ExecutionResponse { + void __clear() { + errorCode = ErrorCode::SUCCEEDED; + latencyInUs = 0; + data.reset(); + spaceName.reset(); + errorMsg.reset(); + planDesc.reset(); + comment.reset(); + } + + void clear() { + __clear(); + } + + bool operator==(const ExecutionResponse &rhs) const { + if (errorCode != rhs.errorCode) { + return false; + } + if (latencyInUs != rhs.latencyInUs) { + return false; + } + if (!checkPointer(data.get(), rhs.data.get())) { + return false; + } + if (!checkPointer(spaceName.get(), rhs.spaceName.get())) { + return false; + } + if (!checkPointer(errorMsg.get(), rhs.errorMsg.get())) { + return false; + } + if (!checkPointer(planDesc.get(), rhs.planDesc.get())) { + return false; + } + if (!checkPointer(comment.get(), rhs.comment.get())) { + return false; + } + return true; + } + + ErrorCode errorCode{ErrorCode::SUCCEEDED}; + int32_t latencyInUs{0}; + std::unique_ptr data{nullptr}; + std::unique_ptr spaceName{nullptr}; + std::unique_ptr errorMsg{nullptr}; + std::unique_ptr planDesc{nullptr}; + std::unique_ptr comment{nullptr}; +}; + +} // namespace nebula diff --git a/include/common/thrift/ThriftCpp2OpsHelper.h b/include/common/thrift/ThriftCpp2OpsHelper.h new file mode 100644 index 00000000..630eca9e --- /dev/null +++ b/include/common/thrift/ThriftCpp2OpsHelper.h @@ -0,0 +1,27 @@ +/* Copyright (c) 2021 vesoft inc. All rights reserved. + * + * This source code is licensed under Apache 2.0 License, + * attached with Common Clause Condition 1.0, found in the LICENSES directory. + */ + +#ifndef COMMON_THRIFT_THRIFTCPP2OPS_HELPER_H_ +#define COMMON_THRIFT_THRIFTCPP2OPS_HELPER_H_ +#include + +#define SPECIALIZE_CPP2OPS(X) \ + template <> \ + class Cpp2Ops { \ + public: \ + using Type = X; \ + inline static constexpr protocol::TType thriftType(); \ + template \ + static uint32_t write(Protocol *proto, const Type *obj); \ + template \ + static void read(Protocol *proto, Type *obj); \ + template \ + static uint32_t serializedSize(const Protocol *proto, const Type *obj); \ + template \ + static uint32_t serializedSizeZC(const Protocol *proto, const Type *obj); \ + } + +#endif // COMMON_THRIFT_THRIFTCPP2OPS_HELPER_H_ diff --git a/include/common/thrift/ThriftTypes.h b/include/common/thrift/ThriftTypes.h new file mode 100644 index 00000000..6a9fb4f0 --- /dev/null +++ b/include/common/thrift/ThriftTypes.h @@ -0,0 +1,49 @@ +/* Copyright (c) 2018 vesoft inc. All rights reserved. + * + * This source code is licensed under Apache 2.0 License, + * attached with Common Clause Condition 1.0, found in the LICENSES directory. + */ + +#pragma once + +#include +#include + +namespace nebula { +// Raft related types +using ClusterID = int64_t; +using GraphSpaceID = int32_t; +using PartitionID = int32_t; +using TermID = int64_t; +using LogID = int64_t; +using Port = int32_t; + +// Starting from 2.0, both string and int64 vertex ids will be supported. +// +// The string id must be fixed-length (the length of the id will be specified +// as a Graph Space property). So the int64 id will be treated as 8-byte string +// +// If the length of a given id is shorter than the specified length, '\0' will +// be appended to the end +using VertexID = std::string; +using TagID = int32_t; +using TagVersion = int64_t; +using EdgeType = int32_t; +using EdgeRanking = int64_t; +using EdgeVersion = int64_t; +using EdgeVerPlaceHolder = char; +using SchemaVer = int64_t; +using IndexID = int32_t; +using Timestamp = int64_t; + +using JobID = int32_t; +using TaskID = int32_t; +using BalanceID = int64_t; + +using GroupID = int32_t; +using ZoneID = int32_t; + +using SessionID = int64_t; + +using ExecutionPlanID = int64_t; +} // namespace nebula diff --git a/include/common/time/TimeConversion.h b/include/common/time/TimeConversion.h new file mode 100644 index 00000000..07086932 --- /dev/null +++ b/include/common/time/TimeConversion.h @@ -0,0 +1,120 @@ +/* Copyright (c) 2021 vesoft inc. All rights reserved. + * + * This source code is licensed under Apache 2.0 License, + * attached with Common Clause Condition 1.0, found in the LICENSES directory. + */ + +#pragma once + +#include + +#include "common/datatypes/Date.h" + +namespace nebula { +namespace time { + +class TimeConversion { +public: + explicit TimeConversion(...) = delete; + + static int64_t dateTimeDiffSeconds(const DateTime &dateTime0, const DateTime &dateTime1); + + // unix time + static int64_t dateTimeToUnixSeconds(const DateTime &dateTime) { + return dateTimeDiffSeconds(dateTime, kEpoch); + } + + static DateTime unixSecondsToDateTime(int64_t seconds); + + // Shift the DateTime in timezone space + static DateTime dateTimeShift(const DateTime &dateTime, int64_t offsetSeconds) { + if (offsetSeconds == 0) { + return dateTime; + } + auto dt = unixSecondsToDateTime(dateTimeToUnixSeconds(dateTime) + offsetSeconds); + dt.microsec = dateTime.microsec; + return dt; + } + + // unix time + static int64_t dateToUnixSeconds(const Date &date) { + return dateTimeDiffSeconds(DateTime(date), kEpoch); + } + + static Date unixSecondsToDate(int64_t seconds) { + auto dateTime = unixSecondsToDateTime(seconds); + return Date(dateTime.year, dateTime.month, dateTime.day); + } + + // Shift the DateTime in timezone space + static Date dateShift(const Date &date, int64_t offsetSeconds) { + if (offsetSeconds == 0) { + return date; + } + return unixSecondsToDate(dateToUnixSeconds(date) + offsetSeconds); + } + + // unix time + static int64_t timeToSeconds(const Time &time) { + int64_t seconds = time.sec; + seconds += (time.minute * kSecondsOfMinute); + seconds += (time.hour * kSecondsOfHour); + return seconds; + } + + static Time unixSecondsToTime(int64_t seconds) { + Time t; + auto dt = unixSecondsToDateTime(seconds); + t.hour = dt.hour; + t.minute = dt.minute; + t.sec = dt.sec; + return t; + } + + // Shift the Time in timezone space + static Time timeShift(const Time &time, int64_t offsetSeconds) { + if (offsetSeconds == 0) { + return time; + } + auto t = unixSecondsToTime(timeToSeconds(time) + offsetSeconds); + t.microsec = time.microsec; + return t; + } + + // https://en.wikipedia.org/wiki/Leap_year#Leap_day + static bool isLeapYear(int16_t year) { + if (year % 4 != 0) { + return false; + } else if (year % 100 != 0) { + return true; + } else if (year % 400 != 0) { + return false; + } else { + return true; + } + } + + static const DateTime kEpoch; + + static constexpr int kDayOfLeapYear = 366; + static constexpr int kDayOfCommonYear = 365; + + static constexpr int64_t kSecondsOfMinute = 60; + static constexpr int64_t kSecondsOfHour = 60 * kSecondsOfMinute; + static constexpr int64_t kSecondsOfDay = 24 * kSecondsOfHour; + +private: + // The result of a right-shift of a signed negative number is + // implementation-dependent (UB. see + // https://en.cppreference.com/w/cpp/language/operator_arithmetic). So make + // sure the result is what we expected, if right shift not filled highest bit + // by the sign bit that the process will falls back to procedure which fill + // hightest bit by the sign bit value. + static int64_t shr(int64_t a, int b) { + int64_t one = 1; + return (-one >> 1 == -1 ? a >> b : (a + (a < 0)) / (one << b) - (a < 0)); + } +}; + +} // namespace time +} // namespace nebula diff --git a/include/common/utils/utils.h b/include/common/utils/utils.h new file mode 100644 index 00000000..6879a531 --- /dev/null +++ b/include/common/utils/utils.h @@ -0,0 +1,16 @@ +/* Copyright (c) 2021 vesoft inc. All rights reserved. + * + * This source code is licensed under Apache 2.0 License, + * attached with Common Clause Condition 1.0, found in the LICENSES directory. + */ + +#pragma once + +#ifndef MAYBE_UNUSED +#if (__cplusplus >= 201703L) // c++17 +#include +#define MAYBE_UNUSED FOLLY_MAYBE_UNUSED +#else +#define MAYBE_UNUSED __attribute__((unused)) +#endif +#endif diff --git a/include/nebula/client/Connection.h b/include/nebula/client/Connection.h index 27edd701..aed47766 100644 --- a/include/nebula/client/Connection.h +++ b/include/nebula/client/Connection.h @@ -23,7 +23,7 @@ namespace graph { namespace cpp2 { class GraphServiceAsyncClient; } -} +} // namespace graph class Connection { public: @@ -69,7 +69,7 @@ class Connection { private: graph::cpp2::GraphServiceAsyncClient *client_{nullptr}; - folly::ScopedEventBaseThread *clientLoopThread_{nullptr}; + folly::ScopedEventBaseThread *clientLoopThread_{nullptr}; }; } // namespace nebula diff --git a/include/nebula/client/ConnectionPool.h b/include/nebula/client/ConnectionPool.h index 576fa78b..bb68b557 100644 --- a/include/nebula/client/ConnectionPool.h +++ b/include/nebula/client/ConnectionPool.h @@ -46,10 +46,10 @@ class ConnectionPool { return cursor_ >= address_.size() ? cursor_ = 0 : cursor_++; } - std::size_t cursor_{0}; + std::size_t cursor_{0}; // host, port std::vector> address_; - Config config_; + Config config_; mutable std::mutex lock_; std::list conns_; diff --git a/include/nebula/client/Session.h b/include/nebula/client/Session.h index 8069a6ff..e24f5d70 100644 --- a/include/nebula/client/Session.h +++ b/include/nebula/client/Session.h @@ -68,7 +68,7 @@ class Session { return sessionId_ > 0; } - const std::string& timeZoneName() const { + const std::string &timeZoneName() const { return timezoneName_; } diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 5e440b6a..cd3272ae 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -4,12 +4,8 @@ # attached with Common Clause Condition 1.0, found in the LICENSES directory. set(NEBULA_CLIENT_OBJS - $ - $ - $ - $ - $ - $ + $ + $ ) set(NEBULA_CLIENT_SOURCES @@ -17,6 +13,18 @@ set(NEBULA_CLIENT_SOURCES client/Init.cpp client/ConnectionPool.cpp client/Session.cpp + datatypes/Date.cpp + datatypes/Edge.cpp + datatypes/Geography.cpp + datatypes/HostAddr.cpp + datatypes/List.cpp + datatypes/Map.cpp + datatypes/Path.cpp + datatypes/Set.cpp + datatypes/Value.cpp + datatypes/Vertex.cpp + graph/Response.cpp + time/TimeConversion.cpp ) set(NEBULA_CLIENT_LIBRARIES @@ -51,6 +59,8 @@ set(NEBULA_CLIENT_LIBRARIES atomic ) +nebula_add_subdirectory(interface) + nebula_add_library( nebula_graph_client SHARED ${NEBULA_CLIENT_OBJS} diff --git a/src/client/Connection.cpp b/src/client/Connection.cpp index cb5d94b6..8c799758 100644 --- a/src/client/Connection.cpp +++ b/src/client/Connection.cpp @@ -11,7 +11,7 @@ #include #include -#include "common/interface/gen-cpp2/GraphServiceAsyncClient.h" +#include "interface/gen-cpp2/GraphServiceAsyncClient.h" #include "nebula/client/Connection.h" namespace nebula { diff --git a/src/client/Session.cpp b/src/client/Session.cpp index 61fb11fe..a7693833 100644 --- a/src/client/Session.cpp +++ b/src/client/Session.cpp @@ -4,10 +4,10 @@ * attached with Common Clause Condition 1.0, found in the LICENSES directory. */ -#include +#include "common/time/TimeConversion.h" -#include "nebula/client/Session.h" #include "nebula/client/ConnectionPool.h" +#include "nebula/client/Session.h" namespace nebula { diff --git a/src/datatypes/Date.cpp b/src/datatypes/Date.cpp new file mode 100644 index 00000000..d4694e6c --- /dev/null +++ b/src/datatypes/Date.cpp @@ -0,0 +1,144 @@ +/* Copyright (c) 2020 vesoft inc. All rights reserved. + * + * This source code is licensed under Apache 2.0 License, + * attached with Common Clause Condition 1.0, found in the LICENSES directory. + */ + +#include "common/datatypes/Date.h" + +#include +#include + +#include + +namespace nebula { + +const int64_t kDaysSoFar[] = {0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365}; +const int64_t kLeapDaysSoFar[] = {0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366}; + +Date::Date(uint64_t days) { + fromInt(days); +} + +int64_t Date::toInt() const { + // Year + int64_t yearsPassed = year + 32768L; + int64_t days = yearsPassed * 365L; + // Add one day per leap year + if (yearsPassed > 0) { + days += (yearsPassed - 1) / 4 + 1; + } + + // Month + if (yearsPassed % 4 == 0) { + // Leap year + days += kLeapDaysSoFar[month - 1]; + } else { + days += kDaysSoFar[month - 1]; + } + + // Day + days += day; + + // Since we start from -32768/1/1, we need to reduce one day + return days - 1; +} + +void Date::fromInt(int64_t days) { + // year + int64_t yearsPassed = (days + 1) / 365; + year = yearsPassed - 32768; + int64_t daysInYear = (days + 1) % 365; + + // Deduce the number of days for leap years + if (yearsPassed > 0) { + daysInYear -= (yearsPassed - 1) / 4 + 1; + } + + // Adjust the year if necessary + while (daysInYear <= 0) { + year = year - 1; + if (year % 4 == 0) { + // Leap year + daysInYear += 366; + } else { + daysInYear += 365; + } + } + + // Month and day + month = 1; + while (true) { + if (year % 4 == 0) { + // Leap year + if (daysInYear <= kLeapDaysSoFar[month]) { + day = daysInYear - kLeapDaysSoFar[month - 1]; + break; + } + } else { + if (daysInYear <= kDaysSoFar[month]) { + day = daysInYear - kDaysSoFar[month - 1]; + break; + } + } + month++; + } +} + +Date Date::operator+(int64_t days) const { + int64_t daysSince = toInt(); + return Date(daysSince + days); +} + +Date Date::operator-(int64_t days) const { + int64_t daysSince = toInt(); + return Date(daysSince - days); +} + +std::string Date::toString() const { + // It's in current timezone already + return folly::stringPrintf("%d-%02d-%02d", year, month, day); +} + +std::string Time::toString() const { + // It's in current timezone already + return folly::stringPrintf("%02d:%02d:%02d.%06d", hour, minute, sec, microsec); +} + +std::string DateTime::toString() const { + // It's in current timezone already + return folly::stringPrintf("%hd-%02hhu-%02hhu" + "T%02hhu:%02hhu:%02hhu.%u", + static_cast(year), + static_cast(month), + static_cast(day), + static_cast(hour), + static_cast(minute), + static_cast(sec), + static_cast(microsec)); +} + +} // namespace nebula + +namespace std { + +// Inject a customized hash function +std::size_t hash::operator()(const nebula::Date& h) const noexcept { + size_t hv = folly::hash::fnv64_buf(reinterpret_cast(&h.year), sizeof(h.year)); + hv = folly::hash::fnv64_buf(reinterpret_cast(&h.month), sizeof(h.month), hv); + return folly::hash::fnv64_buf(reinterpret_cast(&h.day), sizeof(h.day), hv); +} + +std::size_t hash::operator()(const nebula::Time& h) const noexcept { + std::size_t hv = folly::hash::fnv64_buf(reinterpret_cast(&h.hour), sizeof(h.hour)); + hv = folly::hash::fnv64_buf(reinterpret_cast(&h.minute), sizeof(h.minute), hv); + hv = folly::hash::fnv64_buf(reinterpret_cast(&h.sec), sizeof(h.sec), hv); + return folly::hash::fnv64_buf( + reinterpret_cast(&h.microsec), sizeof(h.microsec), hv); +} + +std::size_t hash::operator()(const nebula::DateTime& h) const noexcept { + return h.qword; +} + +} // namespace std diff --git a/src/datatypes/Edge.cpp b/src/datatypes/Edge.cpp new file mode 100644 index 00000000..7884bc62 --- /dev/null +++ b/src/datatypes/Edge.cpp @@ -0,0 +1,112 @@ +/* Copyright (c) 2020 vesoft inc. All rights reserved. + * + * This source code is licensed under Apache 2.0 License, + * attached with Common Clause Condition 1.0, found in the LICENSES directory. + */ + +#include +#include +#include + +#include + +namespace nebula { + +std::string Edge::toString() const { + std::stringstream os; + os << "(" << src << ")" + << "-" + << "[" << name << "(" << type << ")]" + << "->" + << "(" << dst << ")" + << "@" << ranking; + if (!props.empty()) { + std::vector value(props.size()); + std::transform( + props.begin(), props.end(), value.begin(), [](const auto& iter) -> std::string { + std::stringstream out; + out << iter.first << ":" << iter.second; + return out.str(); + }); + os << " " << folly::join(",", value); + } + return os.str(); +} + +bool Edge::contains(const Value& key) const { + if (!key.isStr()) { + return false; + } + return props.find(key.getStr()) != props.end(); +} + +const Value& Edge::value(const std::string& key) const { + auto find = props.find(key); + if (find != props.end()) { + return find->second; + } else { + return Value::kNullValue; + } +} + +bool Edge::operator<(const Edge& rhs) const { + if (src != rhs.src) { + return src < rhs.src; + } + if (dst != rhs.dst) { + return dst < rhs.dst; + } + if (type != rhs.type) { + return type < rhs.type; + } + if (ranking != rhs.ranking) { + return ranking < rhs.ranking; + } + if (props.size() != rhs.props.size()) { + return props.size() < rhs.props.size(); + } + return false; +} + +bool Edge::operator==(const Edge& rhs) const { + if (type != rhs.type && type != -rhs.type) { + return false; + } + if (type == rhs.type) { + return src == rhs.src && dst == rhs.dst && ranking == rhs.ranking && props == rhs.props; + } + return src == rhs.dst && dst == rhs.src && ranking == rhs.ranking && props == rhs.props; +} + +void Edge::reverse() { + type = -type; + auto tmp = std::move(src); + src = std::move(dst); + dst = std::move(tmp); +} + +void Edge::clear() { + src.clear(); + dst.clear(); + type = 0; + name.clear(); + ranking = 0; + props.clear(); +} + +} // namespace nebula + +namespace std { + +// Inject a customized hash function +std::size_t hash::operator()(const nebula::Edge& h) const noexcept { + const auto& src = h.type > 0 ? h.src.toString() : h.dst.toString(); + const auto& dst = h.type > 0 ? h.dst.toString() : h.src.toString(); + auto type = h.type > 0 ? h.type : -h.type; + size_t hv = folly::hash::fnv64(src); + hv = folly::hash::fnv64(dst, hv); + hv = folly::hash::fnv64_buf(reinterpret_cast(&type), sizeof(type), hv); + return folly::hash::fnv64_buf(reinterpret_cast(&h.ranking), sizeof(h.ranking), hv); +} + +} // namespace std diff --git a/src/datatypes/Geography.cpp b/src/datatypes/Geography.cpp new file mode 100644 index 00000000..85e4732a --- /dev/null +++ b/src/datatypes/Geography.cpp @@ -0,0 +1,23 @@ +/* Copyright (c) 2020 vesoft inc. All rights reserved. + * + * This source code is licensed under Apache 2.0 License, + * attached with Common Clause Condition 1.0, found in the LICENSES directory. + */ + +#include "common/datatypes/Geography.h" + +#include +#include + +#include + +namespace nebula {} // namespace nebula + +namespace std { + +// Inject a customized hash function +std::size_t hash::operator()(const nebula::Geography& h) const noexcept { + return hash{}(h.wkb); +} + +} // namespace std diff --git a/src/datatypes/HostAddr.cpp b/src/datatypes/HostAddr.cpp new file mode 100644 index 00000000..fb9eba96 --- /dev/null +++ b/src/datatypes/HostAddr.cpp @@ -0,0 +1,40 @@ +/* Copyright (c) 2020 vesoft inc. All rights reserved. + * + * This source code is licensed under Apache 2.0 License, + * attached with Common Clause Condition 1.0, found in the LICENSES directory. + */ + +#include "common/datatypes/HostAddr.h" + +#include + +namespace nebula { + +bool HostAddr::operator==(const HostAddr& rhs) const { + return host == rhs.host && port == rhs.port; +} + +bool HostAddr::operator!=(const HostAddr& rhs) const { + return !(*this == rhs); +} + +bool HostAddr::operator<(const HostAddr& rhs) const { + if (host == rhs.host) { + return port < rhs.port; + } + return host < rhs.host; +} + +} // namespace nebula + +namespace std { + +// Inject a customized hash function +std::size_t hash::operator()(const nebula::HostAddr& h) const noexcept { + int64_t code = folly::hash::fnv32_buf(h.host.data(), h.host.size()); + code <<= 32; + code |= folly::hash::fnv32_buf(&(h.port), sizeof(nebula::Port)); + return code; +} + +} // namespace std diff --git a/src/datatypes/List.cpp b/src/datatypes/List.cpp new file mode 100644 index 00000000..c587a92d --- /dev/null +++ b/src/datatypes/List.cpp @@ -0,0 +1,25 @@ +/* Copyright (c) 2020 vesoft inc. All rights reserved. + * + * This source code is licensed under Apache 2.0 License, + * attached with Common Clause Condition 1.0, found in the LICENSES directory. + */ + +#include "common/datatypes/List.h" + +#include + +#include + +namespace nebula { + +std::string List::toString() const { + std::vector value(values.size()); + std::transform(values.begin(), values.end(), value.begin(), [](const auto& v) -> std::string { + return v.toString(); + }); + std::stringstream os; + os << "[" << folly::join(",", value) << "]"; + return os.str(); +} + +} // namespace nebula diff --git a/src/datatypes/Map.cpp b/src/datatypes/Map.cpp new file mode 100644 index 00000000..4be3f4c6 --- /dev/null +++ b/src/datatypes/Map.cpp @@ -0,0 +1,28 @@ +/* Copyright (c) 2020 vesoft inc. All rights reserved. + * + * This source code is licensed under Apache 2.0 License, + * attached with Common Clause Condition 1.0, found in the LICENSES directory. + */ + +#include "common/datatypes/Map.h" + +#include + +#include + +namespace nebula { + +std::string Map::toString() const { + std::vector value(kvs.size()); + std::transform(kvs.begin(), kvs.end(), value.begin(), [](const auto& iter) -> std::string { + std::stringstream out; + out << iter.first << ":" << iter.second; + return out.str(); + }); + + std::stringstream os; + os << "{" << folly::join(",", value) << "}"; + return os.str(); +} + +} // namespace nebula diff --git a/src/datatypes/Path.cpp b/src/datatypes/Path.cpp new file mode 100644 index 00000000..623c8799 --- /dev/null +++ b/src/datatypes/Path.cpp @@ -0,0 +1,101 @@ +/* Copyright (c) 2020 vesoft inc. All rights reserved. + * + * This source code is licensed under Apache 2.0 License, + * attached with Common Clause Condition 1.0, found in the LICENSES directory. + */ + +#include "common/datatypes/Path.h" + +#include +#include + +#include +#include +#include + +namespace nebula { +void Path::reverse() { + if (steps.empty()) { + return; + } + std::reverse(steps.begin(), steps.end()); + swap(src, steps.front().dst); + for (size_t i = 0; i < steps.size() - 1; ++i) { + swap(steps[i].dst, steps[i + 1].dst); + steps[i].type = -steps[i].type; + } + steps.back().type = -steps.back().type; +} + +bool Path::append(Path path) { + if (src != path.src && steps.back().dst != path.src) { + return false; + } + steps.reserve(steps.size() + path.steps.size()); + steps.insert(steps.end(), + std::make_move_iterator(path.steps.begin()), + std::make_move_iterator(path.steps.end())); + return true; +} + +bool Path::hasDuplicateVertices() const { + if (steps.empty()) { + return false; + } + std::unordered_set uniqueVid; + uniqueVid.reserve(steps.size() + 1); + uniqueVid.emplace(src.vid); + for (const auto& step : steps) { + auto ret = uniqueVid.emplace(step.dst.vid); + if (!ret.second) { + return true; + } + } + return false; +} + +bool Path::hasDuplicateEdges() const { + if (steps.size() < 2) { + return false; + } + using Key = std::tuple; + std::unordered_set uniqueSet; + uniqueSet.reserve(steps.size()); + auto srcVid = src.vid; + for (const auto& step : steps) { + const auto& dstVid = step.dst.vid; + bool ret = true; + if (step.type > 0) { + ret = uniqueSet.emplace(srcVid, dstVid, step.type, step.ranking).second; + } else { + ret = uniqueSet.emplace(dstVid, srcVid, -step.type, step.ranking).second; + } + if (!ret) { + return true; + } + srcVid = dstVid; + } + return false; +} + +} // namespace nebula + +namespace std { + +std::size_t hash::operator()(const nebula::Step& h) const noexcept { + size_t hv = hash()(h.dst); + hv = folly::hash::fnv64_buf(reinterpret_cast(&h.type), sizeof(h.type), hv); + return folly::hash::fnv64_buf(reinterpret_cast(&h.ranking), sizeof(h.ranking), hv); +} + +std::size_t hash::operator()(const nebula::Path& h) const noexcept { + size_t hv = hash()(h.src); + for (auto& s : h.steps) { + hv += (hv << 1) + (hv << 4) + (hv << 5) + (hv << 7) + (hv << 8) + (hv << 40); + hv ^= hash()(s); + } + + return hv; +} + +} // namespace std diff --git a/src/datatypes/Set.cpp b/src/datatypes/Set.cpp new file mode 100644 index 00000000..ecfd36ea --- /dev/null +++ b/src/datatypes/Set.cpp @@ -0,0 +1,25 @@ +/* Copyright (c) 2020 vesoft inc. All rights reserved. + * + * This source code is licensed under Apache 2.0 License, + * attached with Common Clause Condition 1.0, found in the LICENSES directory. + */ + +#include "common/datatypes/Set.h" + +#include + +#include + +namespace nebula { + +std::string Set::toString() const { + std::vector value(values.size()); + std::transform(values.begin(), values.end(), value.begin(), [](const auto& v) -> std::string { + return v.toString(); + }); + std::stringstream os; + os << "{" << folly::join(",", value) << "}"; + return os.str(); +} + +} // namespace nebula diff --git a/src/datatypes/Value.cpp b/src/datatypes/Value.cpp new file mode 100644 index 00000000..264283c7 --- /dev/null +++ b/src/datatypes/Value.cpp @@ -0,0 +1,2786 @@ +/* Copyright (c) 2020 vesoft inc. All rights reserved. + * + * This source code is licensed under Apache 2.0 License, + * attached with Common Clause Condition 1.0, found in the LICENSES directory. + */ +#include "common/datatypes/Value.h" + +#include +#include +#include + +#include +#include +#include + +#include "common/datatypes/DataSet.h" +#include "common/datatypes/Edge.h" +#include "common/datatypes/Geography.h" +#include "common/datatypes/List.h" +#include "common/datatypes/Map.h" +#include "common/datatypes/Path.h" +#include "common/datatypes/Set.h" +#include "common/datatypes/Vertex.h" + +namespace std { + +std::size_t hash::operator()(const nebula::Value& v) const noexcept { + switch (v.type()) { + case nebula::Value::Type::__EMPTY__: { + return 0; + } + case nebula::Value::Type::NULLVALUE: { + return ~0UL; + } + case nebula::Value::Type::BOOL: { + return hash()(v.getBool()); + } + case nebula::Value::Type::INT: { + return hash()(v.getInt()); + } + case nebula::Value::Type::FLOAT: { + return hash()(v.getFloat()); + } + case nebula::Value::Type::STRING: { + return hash()(v.getStr()); + } + case nebula::Value::Type::DATE: { + return hash()(v.getDate()); + } + case nebula::Value::Type::TIME: { + return hash()(v.getTime()); + } + case nebula::Value::Type::DATETIME: { + return hash()(v.getDateTime()); + } + case nebula::Value::Type::VERTEX: { + return hash()(v.getVertex()); + } + case nebula::Value::Type::EDGE: { + return hash()(v.getEdge()); + } + case nebula::Value::Type::PATH: { + return hash()(v.getPath()); + } + case nebula::Value::Type::LIST: { + return hash()(v.getList()); + } + case nebula::Value::Type::GEOGRAPHY: { + return hash()(v.getGeography()); + } + case nebula::Value::Type::MAP: { + LOG(FATAL) << "Hash for MAP has not been implemented"; + } + case nebula::Value::Type::SET: { + LOG(FATAL) << "Hash for SET has not been implemented"; + } + case nebula::Value::Type::DATASET: { + LOG(FATAL) << "Hash for DATASET has not been implemented"; + } + default: { + LOG(FATAL) << "Unknown type"; + } + } +} + +} // namespace std + +namespace nebula { + +const Value Value::kEmpty; +const Value Value::kNullValue(NullType::__NULL__); +const Value Value::kNullNaN(NullType::NaN); +const Value Value::kNullBadData(NullType::BAD_DATA); +const Value Value::kNullBadType(NullType::BAD_TYPE); +const Value Value::kNullOverflow(NullType::ERR_OVERFLOW); +const Value Value::kNullUnknownProp(NullType::UNKNOWN_PROP); +const Value Value::kNullDivByZero(NullType::DIV_BY_ZERO); +const Value Value::kNullOutOfRange(NullType::OUT_OF_RANGE); + +const uint64_t Value::kEmptyNullType = Value::Type::__EMPTY__ | Value::Type::NULLVALUE; +const uint64_t Value::kNumericType = Value::Type::INT | Value::Type::FLOAT; + +Value::Value(Value&& rhs) noexcept : type_(Value::Type::__EMPTY__) { + if (this == &rhs) { + return; + } + if (rhs.type_ == Type::__EMPTY__) { + return; + } + switch (rhs.type_) { + case Type::NULLVALUE: { + setN(std::move(rhs.value_.nVal)); + break; + } + case Type::BOOL: { + setB(std::move(rhs.value_.bVal)); + break; + } + case Type::INT: { + setI(std::move(rhs.value_.iVal)); + break; + } + case Type::FLOAT: { + setF(std::move(rhs.value_.fVal)); + break; + } + case Type::STRING: { + setS(std::move(rhs.value_.sVal)); + break; + } + case Type::DATE: { + setD(std::move(rhs.value_.dVal)); + break; + } + case Type::TIME: { + setT(std::move(rhs.value_.tVal)); + break; + } + case Type::DATETIME: { + setDT(std::move(rhs.value_.dtVal)); + break; + } + case Type::VERTEX: { + setV(std::move(rhs.value_.vVal)); + break; + } + case Type::EDGE: { + setE(std::move(rhs.value_.eVal)); + break; + } + case Type::PATH: { + setP(std::move(rhs.value_.pVal)); + break; + } + case Type::LIST: { + setL(std::move(rhs.value_.lVal)); + break; + } + case Type::MAP: { + setM(std::move(rhs.value_.mVal)); + break; + } + case Type::SET: { + setU(std::move(rhs.value_.uVal)); + break; + } + case Type::DATASET: { + setG(std::move(rhs.value_.gVal)); + break; + } + case Type::GEOGRAPHY: { + setGG(std::move(rhs.value_.ggVal)); + break; + } + default: { + assert(false); + break; + } + } + rhs.clear(); +} + +Value::Value(const Value& rhs) : type_(Value::Type::__EMPTY__) { + if (this == &rhs) { + return; + } + if (rhs.type_ == Type::__EMPTY__) { + return; + } + switch (rhs.type_) { + case Type::NULLVALUE: { + setN(rhs.value_.nVal); + break; + } + case Type::BOOL: { + setB(rhs.value_.bVal); + break; + } + case Type::INT: { + setI(rhs.value_.iVal); + break; + } + case Type::FLOAT: { + setF(rhs.value_.fVal); + break; + } + case Type::STRING: { + setS(*rhs.value_.sVal); + break; + } + case Type::DATE: { + setD(rhs.value_.dVal); + break; + } + case Type::TIME: { + setT(rhs.value_.tVal); + break; + } + case Type::DATETIME: { + setDT(rhs.value_.dtVal); + break; + } + case Type::VERTEX: { + setV(rhs.value_.vVal); + break; + } + case Type::EDGE: { + setE(rhs.value_.eVal); + break; + } + case Type::PATH: { + setP(rhs.value_.pVal); + break; + } + case Type::LIST: { + setL(rhs.value_.lVal); + break; + } + case Type::MAP: { + setM(rhs.value_.mVal); + break; + } + case Type::SET: { + setU(rhs.value_.uVal); + break; + } + case Type::DATASET: { + setG(rhs.value_.gVal); + break; + } + case Type::GEOGRAPHY: { + setGG(rhs.value_.ggVal); + break; + } + default: { + assert(false); + break; + } + } +} + +Value::Value(const NullType& v) { + setN(v); +} + +Value::Value(NullType&& v) { + setN(std::move(v)); +} + +Value::Value(const bool& v) { + setB(v); +} + +Value::Value(bool&& v) { + setB(std::move(v)); +} + +Value::Value(const int8_t& v) { + setI(v); +} + +Value::Value(int8_t&& v) { + setI(std::move(v)); +} + +Value::Value(const int16_t& v) { + setI(v); +} + +Value::Value(int16_t&& v) { + setI(std::move(v)); +} + +Value::Value(const int32_t& v) { + setI(v); +} + +Value::Value(int32_t&& v) { + setI(std::move(v)); +} + +Value::Value(const int64_t& v) { + setI(v); +} + +Value::Value(int64_t&& v) { + setI(std::move(v)); +} + +Value::Value(const double& v) { + setF(v); +} + +Value::Value(double&& v) { + setF(std::move(v)); +} + +Value::Value(const std::string& v) { + setS(v); +} + +Value::Value(std::string&& v) { + setS(std::move(v)); +} + +Value::Value(const char* v) { + setS(v); +} + +Value::Value(const Date& v) { + setD(v); +} + +Value::Value(Date&& v) { + setD(std::move(v)); +} + +Value::Value(const Time& v) { + setT(v); +} + +Value::Value(Time&& v) { + setT(std::move(v)); +} + +Value::Value(const DateTime& v) { + setDT(v); +} + +Value::Value(DateTime&& v) { + setDT(std::move(v)); +} + +Value::Value(const Vertex& v) { + setV(v); +} + +Value::Value(Vertex&& v) { + setV(std::move(v)); +} + +Value::Value(const Edge& v) { + setE(v); +} + +Value::Value(Edge&& v) { + setE(std::move(v)); +} + +Value::Value(const Path& v) { + setP(v); +} + +Value::Value(Path&& v) { + setP(std::move(v)); +} + +Value::Value(const List& v) { + auto c = std::make_unique(v); + setL(std::move(c)); +} + +Value::Value(List&& v) { + setL(std::make_unique(std::move(v))); +} + +Value::Value(const Map& v) { + auto c = std::make_unique(v); + setM(std::move(c)); +} + +Value::Value(Map&& v) { + setM(std::make_unique(std::move(v))); +} + +Value::Value(const Set& v) { + auto c = std::make_unique(v); + setU(std::move(c)); +} + +Value::Value(Set&& v) { + setU(std::make_unique(std::move(v))); +} + +Value::Value(const DataSet& v) { + auto c = std::make_unique(v); + setG(std::move(c)); +} + +Value::Value(DataSet&& v) { + setG(std::make_unique(std::move(v))); +} + +Value::Value(const Geography& v) { + setGG(std::make_unique(v)); +} + +Value::Value(Geography&& v) { + setGG(std::make_unique(std::move(v))); +} + +const std::string& Value::typeName() const { + static const std::unordered_map typeNames = { + {Type::__EMPTY__, "__EMPTY__"}, + {Type::NULLVALUE, "__NULL__"}, + {Type::BOOL, "bool"}, + {Type::INT, "int"}, + {Type::FLOAT, "float"}, + {Type::STRING, "string"}, + {Type::DATE, "date"}, + {Type::TIME, "time"}, + {Type::DATETIME, "datetime"}, + {Type::VERTEX, "vertex"}, + {Type::EDGE, "edge"}, + {Type::PATH, "path"}, + {Type::LIST, "list"}, + {Type::MAP, "map"}, + {Type::SET, "set"}, + {Type::DATASET, "dataset"}, + {Type::GEOGRAPHY, "geography"}, + }; + + static const std::unordered_map nullTypes = { + {NullType::__NULL__, "__NULL__"}, + {NullType::NaN, "NaN"}, + {NullType::BAD_DATA, "BAD_DATA"}, + {NullType::BAD_TYPE, "BAD_TYPE"}, + {NullType::ERR_OVERFLOW, "ERR_OVERFLOW"}, + {NullType::UNKNOWN_PROP, "UNKNOWN_PROP"}, + {NullType::DIV_BY_ZERO, "DIV_BY_ZERO"}, + }; + + static const std::string unknownType = "__UNKNOWN__"; + + auto find = typeNames.find(type_); + if (find == typeNames.end()) { + return unknownType; + } + if (find->first == Type::NULLVALUE) { + auto nullFind = nullTypes.find(value_.nVal); + if (nullFind == nullTypes.end()) { + return unknownType; + } + return nullFind->second; + } + return find->second; +} + +void Value::setNull(const NullType& v) { + clear(); + setN(v); +} + +void Value::setNull(NullType&& v) { + clear(); + setN(std::move(v)); +} + +void Value::setBool(const bool& v) { + clear(); + setB(v); +} + +void Value::setBool(bool&& v) { + clear(); + setB(std::move(v)); +} + +void Value::setInt(const int8_t& v) { + clear(); + setI(v); +} + +void Value::setInt(int8_t&& v) { + clear(); + setI(std::move(v)); +} + +void Value::setInt(const int16_t& v) { + clear(); + setI(v); +} + +void Value::setInt(int16_t&& v) { + clear(); + setI(std::move(v)); +} + +void Value::setInt(const int32_t& v) { + clear(); + setI(v); +} + +void Value::setInt(int32_t&& v) { + clear(); + setI(std::move(v)); +} + +void Value::setInt(const int64_t& v) { + clear(); + setI(v); +} + +void Value::setInt(int64_t&& v) { + clear(); + setI(std::move(v)); +} + +void Value::setFloat(const double& v) { + clear(); + setF(v); +} + +void Value::setFloat(double&& v) { + clear(); + setF(std::move(v)); +} + +void Value::setStr(const std::string& v) { + clear(); + setS(v); +} + +void Value::setStr(std::string&& v) { + clear(); + setS(std::move(v)); +} + +void Value::setStr(const char* v) { + clear(); + setS(v); +} + +void Value::setDate(const Date& v) { + clear(); + setD(v); +} + +void Value::setDate(Date&& v) { + clear(); + setD(std::move(v)); +} + +void Value::setTime(const Time& v) { + clear(); + setT(v); +} + +void Value::setTime(Time&& v) { + clear(); + setT(std::move(v)); +} + +void Value::setDateTime(const DateTime& v) { + clear(); + setDT(v); +} + +void Value::setDateTime(DateTime&& v) { + clear(); + setDT(std::move(v)); +} + +void Value::setVertex(const Vertex& v) { + clear(); + setV(v); +} + +void Value::setVertex(Vertex&& v) { + clear(); + setV(std::move(v)); +} + +void Value::setVertex(std::unique_ptr&& v) { + clear(); + setV(std::move(v)); +} + +void Value::setEdge(const Edge& v) { + clear(); + setE(v); +} + +void Value::setEdge(Edge&& v) { + clear(); + setE(std::move(v)); +} + +void Value::setEdge(std::unique_ptr&& v) { + clear(); + setE(std::move(v)); +} + +void Value::setPath(const Path& v) { + clear(); + setP(v); +} + +void Value::setPath(Path&& v) { + clear(); + setP(std::move(v)); +} + +void Value::setPath(std::unique_ptr&& v) { + clear(); + setP(std::move(v)); +} + +void Value::setList(const List& v) { + clear(); + setL(v); +} + +void Value::setList(List&& v) { + clear(); + setL(std::move(v)); +} + +void Value::setList(std::unique_ptr&& v) { + clear(); + setL(std::move(v)); +} + +void Value::setMap(const Map& v) { + clear(); + setM(v); +} + +void Value::setMap(Map&& v) { + clear(); + setM(std::move(v)); +} + +void Value::setMap(std::unique_ptr&& v) { + clear(); + setM(std::move(v)); +} + +void Value::setSet(const Set& v) { + clear(); + setU(v); +} + +void Value::setSet(Set&& v) { + clear(); + setU(std::move(v)); +} + +void Value::setSet(std::unique_ptr&& v) { + clear(); + setU(std::move(v)); +} + +void Value::setDataSet(const DataSet& v) { + clear(); + setG(v); +} + +void Value::setDataSet(DataSet&& v) { + clear(); + setG(std::move(v)); +} + +void Value::setDataSet(std::unique_ptr&& v) { + clear(); + setG(std::move(v)); +} + +void Value::setGeography(const Geography& v) { + clear(); + setGG(v); +} + +void Value::setGeography(Geography&& v) { + clear(); + setGG(std::move(v)); +} + +void Value::setGeography(std::unique_ptr&& v) { + clear(); + setGG(std::move(v)); +} + +const NullType& Value::getNull() const { + CHECK_EQ(type_, Type::NULLVALUE); + return value_.nVal; +} + +const bool& Value::getBool() const { + CHECK_EQ(type_, Type::BOOL); + return value_.bVal; +} + +const int64_t& Value::getInt() const { + CHECK_EQ(type_, Type::INT); + return value_.iVal; +} + +const double& Value::getFloat() const { + CHECK_EQ(type_, Type::FLOAT); + return value_.fVal; +} + +const std::string& Value::getStr() const { + CHECK_EQ(type_, Type::STRING); + return *value_.sVal; +} + +const Date& Value::getDate() const { + CHECK_EQ(type_, Type::DATE); + return value_.dVal; +} + +const Time& Value::getTime() const { + CHECK_EQ(type_, Type::TIME); + return value_.tVal; +} + +const DateTime& Value::getDateTime() const { + CHECK_EQ(type_, Type::DATETIME); + return value_.dtVal; +} + +const Vertex& Value::getVertex() const { + CHECK_EQ(type_, Type::VERTEX); + return *(value_.vVal); +} + +const Vertex* Value::getVertexPtr() const { + CHECK_EQ(type_, Type::VERTEX); + return value_.vVal.get(); +} + +const Edge& Value::getEdge() const { + CHECK_EQ(type_, Type::EDGE); + return *(value_.eVal); +} + +const Edge* Value::getEdgePtr() const { + CHECK_EQ(type_, Type::EDGE); + return value_.eVal.get(); +} + +const Path& Value::getPath() const { + CHECK_EQ(type_, Type::PATH); + return *(value_.pVal); +} + +const Path* Value::getPathPtr() const { + CHECK_EQ(type_, Type::PATH); + return value_.pVal.get(); +} + +const List& Value::getList() const { + CHECK_EQ(type_, Type::LIST); + return *(value_.lVal); +} + +const List* Value::getListPtr() const { + CHECK_EQ(type_, Type::LIST); + return value_.lVal.get(); +} + +const Map& Value::getMap() const { + CHECK_EQ(type_, Type::MAP); + return *(value_.mVal); +} + +const Map* Value::getMapPtr() const { + CHECK_EQ(type_, Type::MAP); + return value_.mVal.get(); +} + +const Set& Value::getSet() const { + CHECK_EQ(type_, Type::SET); + return *(value_.uVal); +} + +const Set* Value::getSetPtr() const { + CHECK_EQ(type_, Type::SET); + return value_.uVal.get(); +} + +const DataSet& Value::getDataSet() const { + CHECK_EQ(type_, Type::DATASET); + return *(value_.gVal); +} + +const DataSet* Value::getDataSetPtr() const { + CHECK_EQ(type_, Type::DATASET); + return value_.gVal.get(); +} + +const Geography& Value::getGeography() const { + CHECK_EQ(type_, Type::GEOGRAPHY); + return *(value_.ggVal); +} + +const Geography* Value::getGeographyPtr() const { + CHECK_EQ(type_, Type::GEOGRAPHY); + return value_.ggVal.get(); +} + +NullType& Value::mutableNull() { + CHECK_EQ(type_, Type::NULLVALUE); + return value_.nVal; +} + +bool& Value::mutableBool() { + CHECK_EQ(type_, Type::BOOL); + return value_.bVal; +} + +int64_t& Value::mutableInt() { + CHECK_EQ(type_, Type::INT); + return value_.iVal; +} + +double& Value::mutableFloat() { + CHECK_EQ(type_, Type::FLOAT); + return value_.fVal; +} + +std::string& Value::mutableStr() { + CHECK_EQ(type_, Type::STRING); + return *value_.sVal; +} + +Date& Value::mutableDate() { + CHECK_EQ(type_, Type::DATE); + return value_.dVal; +} + +Time& Value::mutableTime() { + CHECK_EQ(type_, Type::TIME); + return value_.tVal; +} + +DateTime& Value::mutableDateTime() { + CHECK_EQ(type_, Type::DATETIME); + return value_.dtVal; +} + +Vertex& Value::mutableVertex() { + CHECK_EQ(type_, Type::VERTEX); + return *(value_.vVal); +} + +Edge& Value::mutableEdge() { + CHECK_EQ(type_, Type::EDGE); + return *(value_.eVal); +} + +Path& Value::mutablePath() { + CHECK_EQ(type_, Type::PATH); + return *(value_.pVal); +} + +List& Value::mutableList() { + CHECK_EQ(type_, Type::LIST); + return *(value_.lVal); +} + +Map& Value::mutableMap() { + CHECK_EQ(type_, Type::MAP); + return *(value_.mVal); +} + +Set& Value::mutableSet() { + CHECK_EQ(type_, Type::SET); + return *(value_.uVal); +} + +DataSet& Value::mutableDataSet() { + CHECK_EQ(type_, Type::DATASET); + return *(value_.gVal); +} + +Geography& Value::mutableGeography() { + CHECK_EQ(type_, Type::GEOGRAPHY); + return *(value_.ggVal); +} + +NullType Value::moveNull() { + CHECK_EQ(type_, Type::NULLVALUE); + NullType v = std::move(value_.nVal); + clear(); + return std::move(v); +} + +bool Value::moveBool() { + CHECK_EQ(type_, Type::BOOL); + bool v = std::move(value_.bVal); + clear(); + return std::move(v); +} + +int64_t Value::moveInt() { + CHECK_EQ(type_, Type::INT); + int64_t v = std::move(value_.iVal); + clear(); + return std::move(v); +} + +double Value::moveFloat() { + CHECK_EQ(type_, Type::FLOAT); + double v = std::move(value_.fVal); + clear(); + return std::move(v); +} + +std::string Value::moveStr() { + CHECK_EQ(type_, Type::STRING); + std::string v = std::move(*value_.sVal); + clear(); + return v; +} + +Date Value::moveDate() { + CHECK_EQ(type_, Type::DATE); + Date v = std::move(value_.dVal); + clear(); + return v; +} + +Time Value::moveTime() { + CHECK_EQ(type_, Type::TIME); + Time v = std::move(value_.tVal); + clear(); + return v; +} + +DateTime Value::moveDateTime() { + CHECK_EQ(type_, Type::DATETIME); + DateTime v = std::move(value_.dtVal); + clear(); + return v; +} + +Vertex Value::moveVertex() { + CHECK_EQ(type_, Type::VERTEX); + Vertex v = std::move(*(value_.vVal)); + clear(); + return v; +} + +Edge Value::moveEdge() { + CHECK_EQ(type_, Type::EDGE); + Edge v = std::move(*(value_.eVal)); + clear(); + return v; +} + +Path Value::movePath() { + CHECK_EQ(type_, Type::PATH); + Path v = std::move(*(value_.pVal)); + clear(); + return v; +} + +List Value::moveList() { + CHECK_EQ(type_, Type::LIST); + List list = std::move(*(value_.lVal)); + clear(); + return list; +} + +Map Value::moveMap() { + CHECK_EQ(type_, Type::MAP); + Map map = std::move(*(value_.mVal)); + clear(); + return map; +} + +Set Value::moveSet() { + CHECK_EQ(type_, Type::SET); + Set set = std::move(*(value_.uVal)); + clear(); + return set; +} + +DataSet Value::moveDataSet() { + CHECK_EQ(type_, Type::DATASET); + DataSet ds = std::move(*(value_.gVal)); + clear(); + return ds; +} + +Geography Value::moveGeography() { + CHECK_EQ(type_, Type::GEOGRAPHY); + Geography v = std::move(*(value_.ggVal)); + clear(); + return v; +} + +void Value::clear() { + switch (type_) { + case Type::__EMPTY__: { + return; + } + case Type::NULLVALUE: { + destruct(value_.nVal); + break; + } + case Type::BOOL: { + destruct(value_.bVal); + break; + } + case Type::INT: { + destruct(value_.iVal); + break; + } + case Type::FLOAT: { + destruct(value_.fVal); + break; + } + case Type::STRING: { + destruct(value_.sVal); + break; + } + case Type::DATE: { + destruct(value_.dVal); + break; + } + case Type::TIME: { + destruct(value_.tVal); + break; + } + case Type::DATETIME: { + destruct(value_.dtVal); + break; + } + case Type::VERTEX: { + destruct(value_.vVal); + break; + } + case Type::EDGE: { + destruct(value_.eVal); + break; + } + case Type::PATH: { + destruct(value_.pVal); + break; + } + case Type::LIST: { + destruct(value_.lVal); + break; + } + case Type::MAP: { + destruct(value_.mVal); + break; + } + case Type::SET: { + destruct(value_.uVal); + break; + } + case Type::DATASET: { + destruct(value_.gVal); + break; + } + case Type::GEOGRAPHY: { + destruct(value_.ggVal); + break; + } + } + type_ = Type::__EMPTY__; +} + +Value& Value::operator=(Value&& rhs) noexcept { + if (this == &rhs) { + return *this; + } + clear(); + if (rhs.type_ == Type::__EMPTY__) { + return *this; + } + switch (rhs.type_) { + case Type::NULLVALUE: { + setN(std::move(rhs.value_.nVal)); + break; + } + case Type::BOOL: { + setB(std::move(rhs.value_.bVal)); + break; + } + case Type::INT: { + setI(std::move(rhs.value_.iVal)); + break; + } + case Type::FLOAT: { + setF(std::move(rhs.value_.fVal)); + break; + } + case Type::STRING: { + setS(std::move(rhs.value_.sVal)); + break; + } + case Type::DATE: { + setD(std::move(rhs.value_.dVal)); + break; + } + case Type::TIME: { + setT(std::move(rhs.value_.tVal)); + break; + } + case Type::DATETIME: { + setDT(std::move(rhs.value_.dtVal)); + break; + } + case Type::VERTEX: { + setV(std::move(rhs.value_.vVal)); + break; + } + case Type::EDGE: { + setE(std::move(rhs.value_.eVal)); + break; + } + case Type::PATH: { + setP(std::move(rhs.value_.pVal)); + break; + } + case Type::LIST: { + setL(std::move(rhs.value_.lVal)); + break; + } + case Type::MAP: { + setM(std::move(rhs.value_.mVal)); + break; + } + case Type::SET: { + setU(std::move(rhs.value_.uVal)); + break; + } + case Type::DATASET: { + setG(std::move(rhs.value_.gVal)); + break; + } + case Type::GEOGRAPHY: { + setGG(std::move(rhs.value_.ggVal)); + break; + } + default: { + assert(false); + break; + } + } + rhs.clear(); + return *this; +} + +Value& Value::operator=(const Value& rhs) { + if (this == &rhs) { + return *this; + } + clear(); + if (rhs.type_ == Type::__EMPTY__) { + return *this; + } + switch (rhs.type_) { + case Type::NULLVALUE: { + setN(rhs.value_.nVal); + break; + } + case Type::BOOL: { + setB(rhs.value_.bVal); + break; + } + case Type::INT: { + setI(rhs.value_.iVal); + break; + } + case Type::FLOAT: { + setF(rhs.value_.fVal); + break; + } + case Type::STRING: { + setS(*rhs.value_.sVal); + break; + } + case Type::DATE: { + setD(rhs.value_.dVal); + break; + } + case Type::TIME: { + setT(rhs.value_.tVal); + break; + } + case Type::DATETIME: { + setDT(rhs.value_.dtVal); + break; + } + case Type::VERTEX: { + setV(rhs.value_.vVal); + break; + } + case Type::EDGE: { + setE(rhs.value_.eVal); + break; + } + case Type::PATH: { + setP(rhs.value_.pVal); + break; + } + case Type::LIST: { + setL(rhs.value_.lVal); + break; + } + case Type::MAP: { + setM(rhs.value_.mVal); + break; + } + case Type::SET: { + setU(rhs.value_.uVal); + break; + } + case Type::DATASET: { + setG(rhs.value_.gVal); + break; + } + case Type::GEOGRAPHY: { + setGG(rhs.value_.ggVal); + break; + } + default: { + assert(false); + break; + } + } + type_ = rhs.type_; + return *this; +} + +void Value::setN(const NullType& v) { + type_ = Type::NULLVALUE; + new (std::addressof(value_.nVal)) NullType(v); +} + +void Value::setN(NullType&& v) { + type_ = Type::NULLVALUE; + new (std::addressof(value_.nVal)) NullType(std::move(v)); +} + +void Value::setB(const bool& v) { + type_ = Type::BOOL; + new (std::addressof(value_.bVal)) bool(v); // NOLINT +} + +void Value::setB(bool&& v) { + type_ = Type::BOOL; + new (std::addressof(value_.bVal)) bool(std::move(v)); // NOLINT +} + +void Value::setI(const int64_t& v) { + type_ = Type::INT; + new (std::addressof(value_.iVal)) int64_t(v); // NOLINT +} + +void Value::setI(int64_t&& v) { + type_ = Type::INT; + new (std::addressof(value_.iVal)) int64_t(std::move(v)); // NOLINT +} + +void Value::setF(const double& v) { + type_ = Type::FLOAT; + new (std::addressof(value_.fVal)) double(v); // NOLINT +} + +void Value::setF(double&& v) { + type_ = Type::FLOAT; + new (std::addressof(value_.fVal)) double(std::move(v)); // NOLINT +} + +void Value::setS(std::unique_ptr v) { + type_ = Type::STRING; + new (std::addressof(value_.sVal)) std::unique_ptr(std::move(v)); +} + +void Value::setS(const std::string& v) { + type_ = Type::STRING; + new (std::addressof(value_.sVal)) std::unique_ptr(new std::string(v)); +} + +void Value::setS(std::string&& v) { + type_ = Type::STRING; + new (std::addressof(value_.sVal)) std::unique_ptr(new std::string(std::move(v))); +} + +void Value::setS(const char* v) { + type_ = Type::STRING; + new (std::addressof(value_.sVal)) std::unique_ptr(new std::string(v)); +} + +void Value::setD(const Date& v) { + type_ = Type::DATE; + new (std::addressof(value_.dVal)) Date(v); +} + +void Value::setD(Date&& v) { + type_ = Type::DATE; + new (std::addressof(value_.dVal)) Date(std::move(v)); +} + +void Value::setT(const Time& v) { + type_ = Type::TIME; + new (std::addressof(value_.tVal)) Time(v); +} + +void Value::setT(Time&& v) { + type_ = Type::TIME; + new (std::addressof(value_.tVal)) Time(std::move(v)); +} + +void Value::setDT(const DateTime& v) { + type_ = Type::DATETIME; + new (std::addressof(value_.dtVal)) DateTime(v); +} + +void Value::setDT(DateTime&& v) { + type_ = Type::DATETIME; + new (std::addressof(value_.dtVal)) DateTime(std::move(v)); +} + +void Value::setV(const std::unique_ptr& v) { + type_ = Type::VERTEX; + new (std::addressof(value_.vVal)) std::unique_ptr(new Vertex(*v)); +} + +void Value::setV(std::unique_ptr&& v) { + type_ = Type::VERTEX; + new (std::addressof(value_.vVal)) std::unique_ptr(std::move(v)); +} + +void Value::setV(const Vertex& v) { + type_ = Type::VERTEX; + new (std::addressof(value_.vVal)) std::unique_ptr(new Vertex(v)); +} + +void Value::setV(Vertex&& v) { + type_ = Type::VERTEX; + new (std::addressof(value_.vVal)) std::unique_ptr(new Vertex(std::move(v))); +} + +void Value::setE(const std::unique_ptr& v) { + type_ = Type::EDGE; + new (std::addressof(value_.eVal)) std::unique_ptr(new Edge(*v)); +} + +void Value::setE(std::unique_ptr&& v) { + type_ = Type::EDGE; + new (std::addressof(value_.eVal)) std::unique_ptr(std::move(v)); +} + +void Value::setE(const Edge& v) { + type_ = Type::EDGE; + new (std::addressof(value_.eVal)) std::unique_ptr(new Edge(v)); +} + +void Value::setE(Edge&& v) { + type_ = Type::EDGE; + new (std::addressof(value_.eVal)) std::unique_ptr(new Edge(std::move(v))); +} + +void Value::setP(const std::unique_ptr& v) { + type_ = Type::PATH; + new (std::addressof(value_.pVal)) std::unique_ptr(new Path(*v)); +} + +void Value::setP(std::unique_ptr&& v) { + type_ = Type::PATH; + new (std::addressof(value_.pVal)) std::unique_ptr(std::move(v)); +} + +void Value::setP(const Path& v) { + type_ = Type::PATH; + new (std::addressof(value_.pVal)) std::unique_ptr(new Path(v)); +} + +void Value::setP(Path&& v) { + type_ = Type::PATH; + new (std::addressof(value_.pVal)) std::unique_ptr(new Path(std::move(v))); +} + +void Value::setL(const std::unique_ptr& v) { + type_ = Type::LIST; + new (std::addressof(value_.lVal)) std::unique_ptr(new List(*v)); +} + +void Value::setL(std::unique_ptr&& v) { + type_ = Type::LIST; + new (std::addressof(value_.lVal)) std::unique_ptr(std::move(v)); +} + +void Value::setL(const List& v) { + type_ = Type::LIST; + new (std::addressof(value_.lVal)) std::unique_ptr(new List(v)); +} + +void Value::setL(List&& v) { + type_ = Type::LIST; + new (std::addressof(value_.lVal)) std::unique_ptr(new List(std::move(v))); +} + +void Value::setM(const std::unique_ptr& v) { + type_ = Type::MAP; + new (std::addressof(value_.mVal)) std::unique_ptr(new Map(*v)); +} + +void Value::setM(std::unique_ptr&& v) { + type_ = Type::MAP; + new (std::addressof(value_.mVal)) std::unique_ptr(std::move(v)); +} + +void Value::setM(const Map& v) { + type_ = Type::MAP; + new (std::addressof(value_.mVal)) std::unique_ptr(new Map(v)); +} + +void Value::setM(Map&& v) { + type_ = Type::MAP; + new (std::addressof(value_.mVal)) std::unique_ptr(new Map(std::move(v))); +} + +void Value::setU(const std::unique_ptr& v) { + type_ = Type::SET; + new (std::addressof(value_.uVal)) std::unique_ptr(new Set(*v)); +} + +void Value::setU(std::unique_ptr&& v) { + type_ = Type::SET; + new (std::addressof(value_.uVal)) std::unique_ptr(std::move(v)); +} + +void Value::setU(const Set& v) { + type_ = Type::SET; + new (std::addressof(value_.uVal)) std::unique_ptr(new Set(v)); +} + +void Value::setU(Set&& v) { + type_ = Type::SET; + new (std::addressof(value_.vVal)) std::unique_ptr(new Set(std::move(v))); +} + +void Value::setG(const std::unique_ptr& v) { + type_ = Type::DATASET; + new (std::addressof(value_.gVal)) std::unique_ptr(new DataSet(*v)); +} + +void Value::setG(std::unique_ptr&& v) { + type_ = Type::DATASET; + new (std::addressof(value_.gVal)) std::unique_ptr(std::move(v)); +} + +void Value::setG(const DataSet& v) { + type_ = Type::DATASET; + new (std::addressof(value_.gVal)) std::unique_ptr(new DataSet(v)); +} + +void Value::setG(DataSet&& v) { + type_ = Type::DATASET; + new (std::addressof(value_.gVal)) std::unique_ptr(new DataSet(std::move(v))); +} + +void Value::setGG(const std::unique_ptr& v) { + type_ = Type::GEOGRAPHY; + new (std::addressof(value_.ggVal)) std::unique_ptr(new Geography(*v)); +} + +void Value::setGG(std::unique_ptr&& v) { + type_ = Type::GEOGRAPHY; + new (std::addressof(value_.ggVal)) std::unique_ptr(std::move(v)); +} + +void Value::setGG(const Geography& v) { + type_ = Type::GEOGRAPHY; + new (std::addressof(value_.ggVal)) std::unique_ptr(new Geography(v)); +} + +void Value::setGG(Geography&& v) { + type_ = Type::GEOGRAPHY; + new (std::addressof(value_.ggVal)) std::unique_ptr(new Geography(std::move(v))); +} + +std::string Value::toString() const { + switch (type_) { + case Value::Type::__EMPTY__: { + return "__EMPTY__"; + } + case Value::Type::NULLVALUE: { + switch (getNull()) { + case NullType::__NULL__: + return "NULL"; + case NullType::BAD_DATA: + return "__NULL_BAD_DATA__"; + case NullType::BAD_TYPE: + return "__NULL_BAD_TYPE__"; + case NullType::DIV_BY_ZERO: + return "__NULL_DIV_BY_ZERO__"; + case NullType::ERR_OVERFLOW: + return "__NULL_OVERFLOW__"; + case NullType::NaN: + return "__NULL_NaN__"; + case NullType::UNKNOWN_PROP: + return "__NULL_UNKNOWN_PROP__"; + case NullType::OUT_OF_RANGE: + return "__NULL_OUT_OF_RANGE__"; + } + LOG(FATAL) << "Unknown Null type " << static_cast(getNull()); + } + case Value::Type::BOOL: { + return getBool() ? "true" : "false"; + } + case Value::Type::INT: { + return folly::to(getInt()); + } + case Value::Type::FLOAT: { + return folly::to(getFloat()); + } + case Value::Type::STRING: { + return "\"" + getStr() + "\""; + } + case Value::Type::DATE: { + return getDate().toString(); + } + case Value::Type::TIME: { + return getTime().toString(); + } + case Value::Type::DATETIME: { + return getDateTime().toString(); + } + case Value::Type::EDGE: { + return getEdge().toString(); + } + case Value::Type::VERTEX: { + return getVertex().toString(); + } + case Value::Type::PATH: { + return getPath().toString(); + } + case Value::Type::LIST: { + return getList().toString(); + } + case Value::Type::SET: { + return getSet().toString(); + } + case Value::Type::MAP: { + return getMap().toString(); + } + case Value::Type::DATASET: { + return getDataSet().toString(); + } + case Value::Type::GEOGRAPHY: { + return getGeography().toString(); + } + // no default so the compiler will warning when lack + } + + LOG(FATAL) << "Unknown value type " << static_cast(type_); +} + +Value Value::toBool() const { + switch (type_) { + case Value::Type::__EMPTY__: + case Value::Type::NULLVALUE: { + return Value::kNullValue; + } + case Value::Type::BOOL: { + return *this; + } + case Value::Type::STRING: { + auto str = getStr(); + std::transform(str.begin(), str.end(), str.begin(), ::tolower); + if (str.compare("true") == 0) { + return true; + } + if (str.compare("false") == 0) { + return false; + } + return Value::kNullValue; + } + default: { + return Value::kNullBadType; + } + } +} + +Value Value::toFloat() const { + switch (type_) { + case Value::Type::__EMPTY__: + case Value::Type::NULLVALUE: { + return Value::kNullValue; + } + case Value::Type::INT: { + return static_cast(getInt()); + } + case Value::Type::FLOAT: { + return *this; + } + case Value::Type::STRING: { + const auto& str = getStr(); + char* pEnd; + double val = strtod(str.c_str(), &pEnd); + if (*pEnd != '\0') { + return Value::kNullValue; + } + return val; + } + default: { + return Value::kNullBadType; + } + } +} + +Value Value::toInt() const { + switch (type_) { + case Value::Type::__EMPTY__: + case Value::Type::NULLVALUE: { + return Value::kNullValue; + } + case Value::Type::INT: { + return *this; + } + case Value::Type::FLOAT: { + // Check if float value is in the range of int_64 + // Return min/max int_64 value and false to accommodate Cypher + if (getFloat() <= std::numeric_limits::min()) { + return std::numeric_limits::min(); + } else if (getFloat() >= static_cast(std::numeric_limits::max())) { + return std::numeric_limits::max(); + } + return static_cast(getFloat()); + } + case Value::Type::STRING: { + const auto& str = getStr(); + errno = 0; + char* pEnd; + auto it = std::find(str.begin(), str.end(), '.'); + + auto checkSciNotation = [](std::string s) { + auto it1 = std::find(s.begin(), s.end(), 'e'); + auto it2 = std::find(s.begin(), s.end(), 'E'); + + return (it1 != s.end() || it2 != s.end()); + }; + + auto isSciNotation = checkSciNotation(str); + int64_t val = + (it != str.end() || + isSciNotation) // if the string contains '.' or 'e' or 'E', parse as a double + ? int64_t(strtod(str.c_str(), &pEnd)) // string representing double + : int64_t(strtoll(str.c_str(), &pEnd, 10)); // string representing int + if (*pEnd != '\0') { + return Value::kNullValue; + } + + // Check overflow + if ((val == std::numeric_limits::max() || + val == std::numeric_limits::min()) && + errno == ERANGE) { + return kNullOverflow; + } + return val; + } + default: { + return Value::kNullBadType; + } + } +} + +Value Value::lessThan(const Value& v) const { + if (empty() || v.empty()) { + return (v.isNull() || isNull()) ? Value::kNullValue : Value::kEmpty; + } + auto vType = v.type(); + auto hasNull = (type_ | vType) & Value::Type::NULLVALUE; + auto notSameType = type_ != vType; + auto notBothNumeric = ((type_ | vType) & Value::kNumericType) != Value::kNumericType; + if (hasNull || (notSameType && notBothNumeric)) { + return Value::kNullValue; + } + + switch (type_) { + case Value::Type::BOOL: { + return getBool() < v.getBool(); + } + case Value::Type::INT: { + switch (vType) { + case Value::Type::INT: { + return getInt() < v.getInt(); + } + case Value::Type::FLOAT: { + return (std::abs(getInt() - v.getFloat()) >= kEpsilon && + getInt() < v.getFloat()); + } + default: { + return kNullBadType; + } + } + } + case Value::Type::FLOAT: { + switch (vType) { + case Value::Type::INT: { + return (std::abs(getFloat() - v.getInt()) >= kEpsilon && + getFloat() < v.getInt()); + } + case Value::Type::FLOAT: { + return (std::abs(getFloat() - v.getFloat()) >= kEpsilon && + getFloat() < v.getFloat()); + } + default: { + return kNullBadType; + } + } + } + case Value::Type::STRING: { + return getStr() < v.getStr(); + } + case Value::Type::DATE: { + return getDate() < v.getDate(); + } + case Value::Type::TIME: { + // TODO(shylock) convert to UTC then compare + return getTime() < v.getTime(); + } + case Value::Type::DATETIME: { + // TODO(shylock) convert to UTC then compare + return getDateTime() < v.getDateTime(); + } + case Value::Type::VERTEX: { + return getVertex() < v.getVertex(); + } + case Value::Type::EDGE: { + return getEdge() < v.getEdge(); + } + case Value::Type::PATH: { + return getPath() < v.getPath(); + } + case Value::Type::LIST: { + return getList() < v.getList(); + } + case Value::Type::MAP: { + return getMap() < v.getMap(); + } + case Value::Type::SET: { + return getSet() < v.getSet(); + } + case Value::Type::DATASET: { + return getDataSet() < v.getDataSet(); + } + case Value::Type::GEOGRAPHY: { + return getGeography() < v.getGeography(); + } + case Value::Type::NULLVALUE: + case Value::Type::__EMPTY__: { + return kNullBadType; + } + } + DLOG(FATAL) << "Unknown type " << static_cast(v.type()); + return Value::kNullBadType; +} + +Value Value::equal(const Value& v) const { + if (empty()) { + return v.isNull() ? Value::kNullValue : v.empty(); + } + auto vType = v.type(); + auto hasNull = (type_ | vType) & Value::Type::NULLVALUE; + auto notSameType = type_ != vType; + auto notBothNumeric = ((type_ | vType) & Value::kNumericType) != Value::kNumericType; + if (hasNull) return Value::kNullValue; + if (notSameType && notBothNumeric) { + return false; + } + + switch (type_) { + case Value::Type::BOOL: { + return getBool() == v.getBool(); + } + case Value::Type::INT: { + switch (vType) { + case Value::Type::INT: { + return getInt() == v.getInt(); + } + case Value::Type::FLOAT: { + return std::abs(getInt() - v.getFloat()) < kEpsilon; + } + default: { + return kNullBadType; + } + } + } + case Value::Type::FLOAT: { + switch (vType) { + case Value::Type::INT: { + return std::abs(getFloat() - v.getInt()) < kEpsilon; + } + case Value::Type::FLOAT: { + return std::abs(getFloat() - v.getFloat()) < kEpsilon; + } + default: { + return kNullBadType; + } + } + } + case Value::Type::STRING: { + return getStr() == v.getStr(); + } + case Value::Type::DATE: { + return getDate() == v.getDate(); + } + case Value::Type::TIME: { + // TODO(shylock) convert to UTC then compare + return getTime() == v.getTime(); + } + case Value::Type::DATETIME: { + // TODO(shylock) convert to UTC then compare + return getDateTime() == v.getDateTime(); + } + case Value::Type::VERTEX: { + return getVertex() == v.getVertex(); + } + case Value::Type::EDGE: { + return getEdge() == v.getEdge(); + } + case Value::Type::PATH: { + return getPath() == v.getPath(); + } + case Value::Type::LIST: { + return getList() == v.getList(); + } + case Value::Type::MAP: { + return getMap() == v.getMap(); + } + case Value::Type::SET: { + return getSet() == v.getSet(); + } + case Value::Type::DATASET: { + return getDataSet() == v.getDataSet(); + } + case Value::Type::GEOGRAPHY: { + return getGeography() == v.getGeography(); + } + case Value::Type::NULLVALUE: + case Value::Type::__EMPTY__: { + return false; + } + } + DLOG(FATAL) << "Unknown type " << static_cast(v.type()); + return Value::kNullBadType; +} + +void swap(Value& a, Value& b) { + Value temp(std::move(a)); + a = std::move(b); + b = std::move(temp); +} + +std::ostream& operator<<(std::ostream& os, const Value::Type& type) { + switch (type) { + case Value::Type::__EMPTY__: { + os << "__EMPTY__"; + break; + } + case Value::Type::NULLVALUE: { + os << "NULL"; + break; + } + case Value::Type::BOOL: { + os << "BOOL"; + break; + } + case Value::Type::INT: { + os << "INT"; + break; + } + case Value::Type::FLOAT: { + os << "FLOAT"; + break; + } + case Value::Type::STRING: { + os << "STRING"; + break; + } + case Value::Type::DATE: { + os << "DATE"; + break; + } + case Value::Type::TIME: { + os << "TIME"; + break; + } + case Value::Type::DATETIME: { + os << "DATETIME"; + break; + } + case Value::Type::VERTEX: { + os << "VERTEX"; + break; + } + case Value::Type::EDGE: { + os << "EDGE"; + break; + } + case Value::Type::PATH: { + os << "PATH"; + break; + } + case Value::Type::LIST: { + os << "LIST"; + break; + } + case Value::Type::MAP: { + os << "MAP"; + break; + } + case Value::Type::SET: { + os << "SET"; + break; + } + case Value::Type::DATASET: { + os << "DATASET"; + break; + } + case Value::Type::GEOGRAPHY: { + os << "GEOGRAPHY"; + break; + } + default: { + os << "__UNKNOWN__"; + break; + } + } + + return os; +} + +Value operator+(const Value& lhs, const Value& rhs) { + if (lhs.isNull() || (lhs.empty() && !rhs.isNull())) { + return lhs; + } + if (rhs.isNull() || rhs.empty()) { + return rhs; + } + + switch (lhs.type()) { + case Value::Type::BOOL: { + switch (rhs.type()) { + case Value::Type::STRING: { + return folly::stringPrintf( + "%s%s", lhs.getBool() ? "true" : "false", rhs.getStr().c_str()); + } + case Value::Type::LIST: { + auto ret = rhs.getList(); + ret.values.insert(ret.values.begin(), lhs); + return ret; + } + default: { + return Value::kNullBadType; + } + } + } + case Value::Type::INT: { + switch (rhs.type()) { + case Value::Type::INT: { + int64_t lVal = lhs.getInt(); + int64_t rVal = rhs.getInt(); + int64_t sum; + if (__builtin_add_overflow(lVal, rVal, &sum)) { + return Value::kNullOverflow; + } + return sum; + } + case Value::Type::FLOAT: { + return lhs.getInt() + rhs.getFloat(); + } + case Value::Type::STRING: { + return folly::stringPrintf("%ld%s", lhs.getInt(), rhs.getStr().c_str()); + } + case Value::Type::DATE: { + return rhs.getDate() + lhs.getInt(); + } + case Value::Type::LIST: { + auto ret = rhs.getList(); + ret.values.insert(ret.values.begin(), lhs); + return ret; + } + default: { + return Value::kNullBadType; + } + } + } + case Value::Type::FLOAT: { + switch (rhs.type()) { + case Value::Type::INT: { + return lhs.getFloat() + rhs.getInt(); + } + case Value::Type::FLOAT: { + return lhs.getFloat() + rhs.getFloat(); + } + case Value::Type::STRING: { + return folly::to(lhs.getFloat()) + rhs.getStr(); + } + case Value::Type::LIST: { + auto ret = rhs.getList(); + ret.values.insert(ret.values.begin(), lhs); + return ret; + } + default: { + return Value::kNullBadType; + } + } + } + case Value::Type::STRING: { + switch (rhs.type()) { + case Value::Type::BOOL: { + return folly::stringPrintf( + "%s%s", lhs.getStr().c_str(), rhs.getBool() ? "true" : "false"); + } + case Value::Type::INT: { + return folly::stringPrintf("%s%ld", lhs.getStr().c_str(), rhs.getInt()); + } + case Value::Type::FLOAT: { + return lhs.getStr() + folly::to(rhs.getFloat()); + } + case Value::Type::STRING: { + return lhs.getStr() + rhs.getStr(); + } + case Value::Type::DATE: { + return lhs.getStr() + rhs.getDate().toString(); + } + case Value::Type::TIME: { + return lhs.getStr() + rhs.getTime().toString(); + } + case Value::Type::DATETIME: { + return lhs.getStr() + rhs.getDateTime().toString(); + } + case Value::Type::LIST: { + auto ret = rhs.getList(); + ret.values.insert(ret.values.begin(), lhs); + return ret; + } + default: { + return Value::kNullBadType; + } + } + } + case Value::Type::DATE: { + switch (rhs.type()) { + case Value::Type::INT: { + return lhs.getDate() + rhs.getInt(); + } + case Value::Type::STRING: { + return lhs.getDate().toString() + rhs.getStr(); + } + case Value::Type::LIST: { + auto ret = rhs.getList(); + ret.values.insert(ret.values.begin(), lhs); + return ret; + } + default: { + return Value::kNullBadType; + } + } + } + case Value::Type::TIME: { + switch (rhs.type()) { + case Value::Type::STRING: { + return lhs.getTime().toString() + rhs.getStr(); + } + case Value::Type::LIST: { + auto ret = rhs.getList(); + ret.values.insert(ret.values.begin(), lhs); + return ret; + } + default: { + return Value::kNullBadType; + } + } + } + case Value::Type::DATETIME: { + switch (rhs.type()) { + case Value::Type::STRING: { + return lhs.getDateTime().toString() + rhs.getStr(); + } + case Value::Type::LIST: { + auto ret = rhs.getList(); + ret.values.insert(ret.values.begin(), lhs); + return ret; + } + default: { + return Value::kNullBadType; + } + } + } + case Value::Type::LIST: { + switch (rhs.type()) { + case Value::Type::LIST: { + auto ret = lhs.getList(); + auto& list = rhs.getList(); + ret.values.insert(ret.values.end(), list.values.begin(), list.values.end()); + return ret; + } + case Value::Type::BOOL: + case Value::Type::INT: + case Value::Type::FLOAT: + case Value::Type::STRING: + case Value::Type::DATE: + case Value::Type::TIME: + case Value::Type::DATETIME: + case Value::Type::VERTEX: + case Value::Type::EDGE: + case Value::Type::PATH: + case Value::Type::MAP: + case Value::Type::SET: { + auto ret = lhs.getList(); + ret.emplace_back(rhs); + return ret; + } + case Value::Type::DATASET: { + return Value::kNullBadType; + } + case Value::Type::GEOGRAPHY: { + return Value::kNullBadType; + } + case Value::Type::__EMPTY__: { + return Value::kEmpty; + } + case Value::Type::NULLVALUE: { + return Value::kNullValue; + } + } + LOG(FATAL) << "Unknown type: " << rhs.type(); + } + case Value::Type::VERTEX: { + switch (rhs.type()) { + case Value::Type::LIST: { + auto ret = rhs.getList(); + ret.values.insert(ret.values.begin(), lhs); + return ret; + } + default: { + return Value::kNullBadType; + } + } + } + case Value::Type::EDGE: { + switch (rhs.type()) { + case Value::Type::LIST: { + auto ret = rhs.getList(); + ret.values.insert(ret.values.begin(), lhs); + return ret; + } + default: { + return Value::kNullBadType; + } + } + } + case Value::Type::PATH: { + switch (rhs.type()) { + case Value::Type::LIST: { + auto ret = rhs.getList(); + ret.values.insert(ret.values.begin(), lhs); + return ret; + } + default: { + return Value::kNullBadType; + } + } + } + case Value::Type::MAP: { + switch (rhs.type()) { + case Value::Type::LIST: { + auto ret = rhs.getList(); + ret.values.insert(ret.values.begin(), lhs); + return ret; + } + default: { + return Value::kNullBadType; + } + } + } + case Value::Type::SET: { + switch (rhs.type()) { + case Value::Type::LIST: { + auto ret = rhs.getList(); + ret.values.insert(ret.values.begin(), lhs); + return ret; + } + default: { + return Value::kNullBadType; + } + } + } + default: { + return Value::kNullBadType; + } + } +} + +Value operator-(const Value& lhs, const Value& rhs) { + if (lhs.isNull() || (lhs.empty() && !rhs.isNull())) { + return lhs; + } + if (rhs.isNull() || rhs.empty()) { + return rhs; + } + + switch (lhs.type()) { + case Value::Type::INT: { + switch (rhs.type()) { + case Value::Type::INT: { + int64_t lVal = lhs.getInt(); + int64_t rVal = rhs.getInt(); + int64_t res; + if (__builtin_sub_overflow(lVal, rVal, &res)) { + return Value::kNullOverflow; + } + return res; + } + case Value::Type::FLOAT: { + return lhs.getInt() - rhs.getFloat(); + } + default: { + return Value::kNullBadType; + } + } + } + case Value::Type::FLOAT: { + switch (rhs.type()) { + case Value::Type::INT: { + return lhs.getFloat() - rhs.getInt(); + } + case Value::Type::FLOAT: { + return lhs.getFloat() - rhs.getFloat(); + } + default: { + return Value::kNullBadType; + } + } + } + case Value::Type::DATE: { + switch (rhs.type()) { + case Value::Type::INT: { + return lhs.getDate() - rhs.getInt(); + } + case Value::Type::DATE: { + return lhs.getDate().toInt() - rhs.getDate().toInt(); + } + default: { + return Value::kNullBadType; + } + } + } + default: { + return Value::kNullBadType; + } + } +} + +Value operator*(const Value& lhs, const Value& rhs) { + if (lhs.isNull() || (lhs.empty() && !rhs.isNull())) { + return lhs; + } + if (rhs.isNull() || rhs.empty()) { + return rhs; + } + + switch (lhs.type()) { + case Value::Type::INT: { + switch (rhs.type()) { + case Value::Type::INT: { + int64_t lVal = lhs.getInt(); + int64_t rVal = rhs.getInt(); + // -1 * min causes overflow + if ((lVal == -1 && rVal == INT64_MIN) || (rVal == -1 && lVal == INT64_MIN)) { + return Value::kNullOverflow; + } + int64_t res; + if (__builtin_mul_overflow(lVal, rVal, &res)) { + return Value::kNullOverflow; + } + return res; + } + case Value::Type::FLOAT: { + return lhs.getInt() * rhs.getFloat(); + } + default: { + return Value::kNullBadType; + } + } + } + case Value::Type::FLOAT: { + switch (rhs.type()) { + case Value::Type::INT: { + return lhs.getFloat() * rhs.getInt(); + } + case Value::Type::FLOAT: { + return lhs.getFloat() * rhs.getFloat(); + } + default: { + return Value::kNullBadType; + } + } + } + default: { + return Value::kNullBadType; + } + } +} + +Value operator/(const Value& lhs, const Value& rhs) { + if (lhs.isNull() || (lhs.empty() && !rhs.isNull())) { + return lhs; + } + if (rhs.isNull() || rhs.empty()) { + return rhs; + } + + switch (lhs.type()) { + case Value::Type::INT: { + switch (rhs.type()) { + case Value::Type::INT: { + int64_t denom = rhs.getInt(); + if (denom == 0) { + return Value::kNullDivByZero; + } + int64_t lVal = lhs.getInt(); + // INT_MIN/-1 causes overflow + if (lVal == INT64_MIN && denom == -1) { + return Value::kNullOverflow; + } + return lVal / denom; + } + case Value::Type::FLOAT: { + double denom = rhs.getFloat(); + if (std::abs(denom) > kEpsilon) { + return lhs.getInt() / denom; + } else { + return Value::kNullDivByZero; + } + } + default: { + return Value::kNullBadType; + } + } + } + case Value::Type::FLOAT: { + switch (rhs.type()) { + case Value::Type::INT: { + int64_t denom = rhs.getInt(); + if (denom != 0) { + return lhs.getFloat() / denom; + } else { + return Value::kNullDivByZero; + } + } + case Value::Type::FLOAT: { + double denom = rhs.getFloat(); + if (std::abs(denom) > kEpsilon) { + return lhs.getFloat() / denom; + } else { + return Value::kNullDivByZero; + } + } + default: { + return Value::kNullBadType; + } + } + } + default: { + return Value::kNullBadType; + } + } +} + +Value operator%(const Value& lhs, const Value& rhs) { + if (lhs.isNull() || (lhs.empty() && !rhs.isNull())) { + return lhs; + } + if (rhs.isNull() || rhs.empty()) { + return rhs; + } + + switch (lhs.type()) { + case Value::Type::INT: { + switch (rhs.type()) { + case Value::Type::INT: { + int64_t denom = rhs.getInt(); + if (denom != 0) { + return lhs.getInt() % denom; + } else { + return Value::kNullDivByZero; + } + } + case Value::Type::FLOAT: { + double denom = rhs.getFloat(); + if (std::abs(denom) > kEpsilon) { + return std::fmod(lhs.getInt(), denom); + } else { + return Value::kNullDivByZero; + } + } + default: { + return Value::kNullBadType; + } + } + } + case Value::Type::FLOAT: { + switch (rhs.type()) { + case Value::Type::INT: { + int64_t denom = rhs.getInt(); + if (denom != 0) { + return std::fmod(lhs.getFloat(), denom); + } else { + return Value::kNullDivByZero; + } + } + case Value::Type::FLOAT: { + double denom = rhs.getFloat(); + if (std::abs(denom) > kEpsilon) { + return std::fmod(lhs.getFloat(), denom); + } else { + return Value::kNullDivByZero; + } + } + default: { + return Value::kNullBadType; + } + } + } + default: { + return Value::kNullBadType; + } + } +} + +Value operator-(const Value& rhs) { + if (rhs.isNull() || rhs.empty()) { + return rhs; + } + + switch (rhs.type()) { + case Value::Type::INT: { + int64_t rVal = rhs.getInt(); + if (rVal == INT64_MIN) { + return Value::kNullOverflow; + } + auto val = -rVal; + return val; + } + case Value::Type::FLOAT: { + auto val = -rhs.getFloat(); + return val; + } + default: { + return Value::kNullBadType; + } + } +} + +Value operator!(const Value& rhs) { + if (rhs.isNull() || rhs.empty()) { + return rhs; + } + + if (rhs.type() != Value::Type::BOOL) { + return Value::kNullBadType; + } + + auto val = rhs.getBool(); + return !val; +} + +bool operator<(const Value& lhs, const Value& rhs) { + auto lType = lhs.type(); + auto rType = rhs.type(); + auto hasNullOrEmpty = (lType | rType) & Value::kEmptyNullType; + auto notSameType = lType != rType; + auto notBothNumeric = ((lType | rType) & Value::kNumericType) != Value::kNumericType; + if (hasNullOrEmpty || (notSameType && notBothNumeric)) { + return lType < rType; + } + + switch (lType) { + case Value::Type::BOOL: { + return lhs.getBool() < rhs.getBool(); + } + case Value::Type::INT: { + switch (rType) { + case Value::Type::INT: { + return lhs.getInt() < rhs.getInt(); + } + case Value::Type::FLOAT: { + return lhs.getInt() < rhs.getFloat(); + } + default: { + return false; + } + } + } + case Value::Type::FLOAT: { + switch (rType) { + case Value::Type::INT: { + return lhs.getFloat() < rhs.getInt(); + } + case Value::Type::FLOAT: { + return lhs.getFloat() < rhs.getFloat(); + } + default: { + return false; + } + } + } + case Value::Type::STRING: { + return lhs.getStr() < rhs.getStr(); + } + case Value::Type::VERTEX: { + return lhs.getVertex() < rhs.getVertex(); + } + case Value::Type::EDGE: { + return lhs.getEdge() < rhs.getEdge(); + } + case Value::Type::PATH: { + return lhs.getPath() < rhs.getPath(); + } + case Value::Type::TIME: { + return lhs.getTime() < rhs.getTime(); + } + case Value::Type::DATE: { + return lhs.getDate() < rhs.getDate(); + } + case Value::Type::DATETIME: { + return lhs.getDateTime() < rhs.getDateTime(); + } + case Value::Type::LIST: { + return lhs.getList() < rhs.getList(); + } + case Value::Type::MAP: + case Value::Type::SET: + case Value::Type::DATASET: { + // TODO: + return false; + } + case Value::Type::GEOGRAPHY: { + return lhs.getGeography() < rhs.getGeography(); + } + case Value::Type::NULLVALUE: + case Value::Type::__EMPTY__: { + return false; + } + } + DLOG(FATAL) << "Unknown type " << static_cast(lType); + return false; +} + +bool operator==(const Value& lhs, const Value& rhs) { + auto lType = lhs.type(); + auto rType = rhs.type(); + auto hasNullOrEmpty = (lType | rType) & Value::kEmptyNullType; + auto notSameType = lType != rType; + auto notBothNumeric = ((lType | rType) & Value::kNumericType) != Value::kNumericType; + if (hasNullOrEmpty || (notSameType && notBothNumeric)) { + return lhs.type() == rhs.type(); + } + + switch (lType) { + case Value::Type::BOOL: { + return lhs.getBool() == rhs.getBool(); + } + case Value::Type::INT: { + switch (rType) { + case Value::Type::INT: { + return lhs.getInt() == rhs.getInt(); + } + case Value::Type::FLOAT: { + return std::abs(lhs.getInt() - rhs.getFloat()) < kEpsilon; + } + default: { + return false; + } + } + } + case Value::Type::FLOAT: { + switch (rType) { + case Value::Type::INT: { + return std::abs(lhs.getFloat() - rhs.getInt()) < kEpsilon; + } + case Value::Type::FLOAT: { + return std::abs(lhs.getFloat() - rhs.getFloat()) < kEpsilon; + } + default: { + return false; + } + } + } + case Value::Type::STRING: { + return lhs.getStr() == rhs.getStr(); + } + case Value::Type::DATE: { + return lhs.getDate() == rhs.getDate(); + } + case Value::Type::TIME: { + // TODO(shylock) convert to UTC then compare + return lhs.getTime() == rhs.getTime(); + } + case Value::Type::DATETIME: { + // TODO(shylock) convert to UTC then compare + return lhs.getDateTime() == rhs.getDateTime(); + } + case Value::Type::VERTEX: { + return lhs.getVertex() == rhs.getVertex(); + } + case Value::Type::EDGE: { + return lhs.getEdge() == rhs.getEdge(); + } + case Value::Type::PATH: { + return lhs.getPath() == rhs.getPath(); + } + case Value::Type::LIST: { + return lhs.getList() == rhs.getList(); + } + case Value::Type::MAP: { + return lhs.getMap() == rhs.getMap(); + } + case Value::Type::SET: { + return lhs.getSet() == rhs.getSet(); + } + case Value::Type::DATASET: { + return lhs.getDataSet() == rhs.getDataSet(); + } + case Value::Type::GEOGRAPHY: { + return lhs.getGeography() == rhs.getGeography(); + } + case Value::Type::NULLVALUE: + case Value::Type::__EMPTY__: { + return false; + } + } + DLOG(FATAL) << "Unknown type " << static_cast(lhs.type()); + return false; +} + +bool operator!=(const Value& lhs, const Value& rhs) { + return !(lhs == rhs); +} + +bool operator>(const Value& lhs, const Value& rhs) { + return rhs < lhs; +} + +bool operator<=(const Value& lhs, const Value& rhs) { + return !(rhs < lhs); +} + +bool operator>=(const Value& lhs, const Value& rhs) { + return !(lhs < rhs); +} + +Value operator&&(const Value& lhs, const Value& rhs) { + if (lhs.isNull()) { + return lhs.getNull(); + } + + if (rhs.isNull()) { + return rhs.getNull(); + } + + if (lhs.empty() || rhs.empty()) { + return Value::kEmpty; + } + + if (lhs.type() == Value::Type::BOOL && rhs.type() == Value::Type::BOOL) { + return lhs.getBool() && rhs.getBool(); + } else { + return Value::kNullBadType; + } +} + +Value operator||(const Value& lhs, const Value& rhs) { + if (lhs.isNull()) { + return lhs.getNull(); + } + + if (rhs.isNull()) { + return rhs.getNull(); + } + + if (lhs.empty() || rhs.empty()) { + return Value::kEmpty; + } + + if (lhs.type() == Value::Type::BOOL && rhs.type() == Value::Type::BOOL) { + return lhs.getBool() || rhs.getBool(); + } else { + return Value::kNullBadType; + } +} + +Value operator&(const Value& lhs, const Value& rhs) { + if (lhs.isNull() || (lhs.empty() && !rhs.isNull())) { + return lhs; + } + + if (rhs.isNull() || rhs.empty()) { + return rhs; + } + + if (!lhs.isInt() || lhs.type() != rhs.type()) { + return Value::kNullBadType; + } + + switch (lhs.type()) { + case Value::Type::INT: { + return lhs.getInt() & rhs.getInt(); + } + default: { + return Value::kNullBadType; + } + } +} + +Value operator|(const Value& lhs, const Value& rhs) { + if (lhs.isNull() || (lhs.empty() && !rhs.isNull())) { + return lhs; + } + + if (rhs.isNull() || rhs.empty()) { + return rhs; + } + + if (!lhs.isInt() || lhs.type() != rhs.type()) { + return Value::kNullBadType; + } + + switch (lhs.type()) { + case Value::Type::INT: { + return lhs.getInt() | rhs.getInt(); + } + default: { + return Value::kNullBadType; + } + } +} + +Value operator^(const Value& lhs, const Value& rhs) { + if (lhs.isNull() || (lhs.empty() && !rhs.isNull())) { + return lhs; + } + + if (rhs.isNull() || rhs.empty()) { + return rhs; + } + + if (!lhs.isInt() || lhs.type() != rhs.type()) { + return Value::kNullBadType; + } + + switch (lhs.type()) { + case Value::Type::INT: { + return lhs.getInt() ^ rhs.getInt(); + } + default: { + return Value::kNullBadType; + } + } +} +} // namespace nebula diff --git a/src/datatypes/Vertex.cpp b/src/datatypes/Vertex.cpp new file mode 100644 index 00000000..5e36be56 --- /dev/null +++ b/src/datatypes/Vertex.cpp @@ -0,0 +1,108 @@ +/* Copyright (c) 2020 vesoft inc. All rights reserved. + * + * This source code is licensed under Apache 2.0 License, + * attached with Common Clause Condition 1.0, found in the LICENSES directory. + */ + +#include "common/datatypes/Vertex.h" + +#include +#include +#include + +namespace nebula { + +std::string Tag::toString() const { + std::vector value(props.size()); + std::transform(props.begin(), props.end(), value.begin(), [](const auto& iter) -> std::string { + std::stringstream out; + out << iter.first << ":" << iter.second; + return out.str(); + }); + + std::stringstream os; + os << "Tag: " << name << ", " << folly::join(",", value); + return os.str(); +} + +bool Vertex::contains(const Value& key) const { + if (!key.isStr()) { + return false; + } + auto& keyStr = key.getStr(); + for (const auto& tag : tags) { + if (tag.props.find(keyStr) != tag.props.end()) { + return true; + } + } + return false; +} + +const Value& Vertex::value(const std::string& key) const { + for (const auto& tag : tags) { + auto find = tag.props.find(key); + if (find != tag.props.end()) { + return find->second; + } + } + return Value::kNullValue; +} + +std::string Vertex::toString() const { + std::stringstream os; + os << "(" << vid << ")"; + if (!tags.empty()) { + os << " "; + for (const auto& tag : tags) { + os << tag.toString(); + } + } + return os.str(); +} + +Vertex& Vertex::operator=(Vertex&& rhs) noexcept { + if (&rhs != this) { + vid = std::move(rhs.vid); + tags = std::move(rhs.tags); + } + return *this; +} + +Vertex& Vertex::operator=(const Vertex& rhs) { + if (&rhs != this) { + vid = rhs.vid; + tags = rhs.tags; + } + return *this; +} + +bool Vertex::operator<(const Vertex& rhs) const { + if (vid != rhs.vid) { + return vid < rhs.vid; + } + if (tags.size() != rhs.tags.size()) { + return tags.size() < rhs.tags.size(); + } + return false; +} + +} // namespace nebula + +namespace std { + +// Inject a customized hash function +std::size_t hash::operator()(const nebula::Tag& h) const noexcept { + return folly::hash::fnv64(h.name); +} + +std::size_t hash::operator()(const nebula::Vertex& h) const noexcept { + size_t hv = folly::hash::fnv64(h.vid.toString()); + for (auto& t : h.tags) { + hv += (hv << 1) + (hv << 4) + (hv << 5) + (hv << 7) + (hv << 8) + (hv << 40); + hv ^= hash()(t); + } + + return hv; +} + +} // namespace std diff --git a/src/graph/Response.cpp b/src/graph/Response.cpp new file mode 100644 index 00000000..4a21076a --- /dev/null +++ b/src/graph/Response.cpp @@ -0,0 +1,41 @@ +/* Copyright (c) 2020 vesoft inc. All rights reserved. + * + * This source code is licensed under Apache 2.0 License, + * attached with Common Clause Condition 1.0, found in the LICENSES directory. + */ + +#include "common/graph/Response.h" + +namespace nebula { + +bool PlanNodeDescription::operator==(const PlanNodeDescription& rhs) const { + if (name != rhs.name) { + return false; + } + if (id != rhs.id) { + return false; + } + if (!checkPointer(description.get(), rhs.description.get())) { + return false; + } + if (!checkPointer(profiles.get(), rhs.profiles.get())) { + return false; + } + if (!checkPointer(branchInfo.get(), rhs.branchInfo.get())) { + return false; + } + return checkPointer(dependencies.get(), rhs.dependencies.get()); +} + +#define X(EnumName, EnumNumber) \ + case ErrorCode::EnumName: \ + return #EnumName; + +const char* getErrorCode(ErrorCode code) { + switch (code) { ErrorCodeEnums } + return "Unknown error"; +} + +#undef X + +} // namespace nebula diff --git a/src/interface/CMakeLists.txt b/src/interface/CMakeLists.txt new file mode 100644 index 00000000..69564f76 --- /dev/null +++ b/src/interface/CMakeLists.txt @@ -0,0 +1,54 @@ +# Copyright (c) 2021 vesoft inc. All rights reserved. +# +# This source code is licensed under Apache 2.0 License, +# attached with Common Clause Condition 1.0, found in the LICENSES directory. + +if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU") + add_compile_options(-Wno-maybe-uninitialized) +endif() + +foreach(mod "common" "graph") + set(${mod}-cpp2-HEADERS + ${CMAKE_SOURCE_DIR}/src/interface/gen-cpp2/${mod}_constants.h + ${CMAKE_SOURCE_DIR}/src/interface/gen-cpp2/${mod}_data.h + ${CMAKE_SOURCE_DIR}/src/interface/gen-cpp2/${mod}_types.h + ${CMAKE_SOURCE_DIR}/src/interface/gen-cpp2/${mod}_types_custom_protocol.h + ${CMAKE_SOURCE_DIR}/src/interface/gen-cpp2/${mod}_types.tcc + ) + + set(${mod}-cpp2-SOURCES + ${CMAKE_SOURCE_DIR}/src/interface/gen-cpp2/${mod}_constants.cpp + ${CMAKE_SOURCE_DIR}/src/interface/gen-cpp2/${mod}_data.cpp + ${CMAKE_SOURCE_DIR}/src/interface/gen-cpp2/${mod}_metadata.cpp + ${CMAKE_SOURCE_DIR}/src/interface/gen-cpp2/${mod}_types.cpp + ) +endforeach() + +set(graph-cpp2-HEADERS +${graph-cpp2-HEADERS} +${CMAKE_SOURCE_DIR}/src/interface/gen-cpp2/GraphService.h +${CMAKE_SOURCE_DIR}/src/interface/gen-cpp2/GraphService.tcc +${CMAKE_SOURCE_DIR}/src/interface/gen-cpp2/GraphServiceAsyncClient.h +${CMAKE_SOURCE_DIR}/src/interface/gen-cpp2/GraphService_custom_protocol.h +) +set(graph-cpp2-SOURCES +${graph-cpp2-SOURCES} +${CMAKE_SOURCE_DIR}/src/interface/gen-cpp2/GraphService.cpp +${CMAKE_SOURCE_DIR}/src/interface/gen-cpp2/GraphServiceAsyncClient.cpp +${CMAKE_SOURCE_DIR}/src/interface/gen-cpp2/GraphService_processmap_binary.cpp +${CMAKE_SOURCE_DIR}/src/interface/gen-cpp2/GraphService_processmap_compact.cpp +) + +add_compile_options(-fPIC) + +add_library( + "common_thrift_obj" + OBJECT + ${common-cpp2-SOURCES} +) + +add_library( + "graph_thrift_obj" + OBJECT + ${graph-cpp2-SOURCES} +) diff --git a/src/interface/gen-cpp2/GeneralStorageService.cpp b/src/interface/gen-cpp2/GeneralStorageService.cpp new file mode 100644 index 00000000..7d727983 --- /dev/null +++ b/src/interface/gen-cpp2/GeneralStorageService.cpp @@ -0,0 +1,125 @@ +/** + * Autogenerated by Thrift for storage.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#include "GeneralStorageService.h" +#include "GeneralStorageService.tcc" +#include "storage_metadata.h" +#include + +namespace nebula { namespace storage { namespace cpp2 { +std::unique_ptr GeneralStorageServiceSvIf::getProcessor() { + return std::make_unique(this); +} + + +void GeneralStorageServiceSvIf::get( ::nebula::storage::cpp2::KVGetResponse& /*_return*/, const ::nebula::storage::cpp2::KVGetRequest& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("get"); +} + +folly::SemiFuture< ::nebula::storage::cpp2::KVGetResponse> GeneralStorageServiceSvIf::semifuture_get(const ::nebula::storage::cpp2::KVGetRequest& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::storage::cpp2::KVGetResponse& _return) { get(_return, p_req); }); +} + +folly::Future< ::nebula::storage::cpp2::KVGetResponse> GeneralStorageServiceSvIf::future_get(const ::nebula::storage::cpp2::KVGetRequest& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_get(p_req), std::move(ka)); +} + +void GeneralStorageServiceSvIf::async_tm_get(std::unique_ptr> callback, const ::nebula::storage::cpp2::KVGetRequest& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_get(p_req); + }); +} + +void GeneralStorageServiceSvIf::put( ::nebula::storage::cpp2::ExecResponse& /*_return*/, const ::nebula::storage::cpp2::KVPutRequest& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("put"); +} + +folly::SemiFuture< ::nebula::storage::cpp2::ExecResponse> GeneralStorageServiceSvIf::semifuture_put(const ::nebula::storage::cpp2::KVPutRequest& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::storage::cpp2::ExecResponse& _return) { put(_return, p_req); }); +} + +folly::Future< ::nebula::storage::cpp2::ExecResponse> GeneralStorageServiceSvIf::future_put(const ::nebula::storage::cpp2::KVPutRequest& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_put(p_req), std::move(ka)); +} + +void GeneralStorageServiceSvIf::async_tm_put(std::unique_ptr> callback, const ::nebula::storage::cpp2::KVPutRequest& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_put(p_req); + }); +} + +void GeneralStorageServiceSvIf::remove( ::nebula::storage::cpp2::ExecResponse& /*_return*/, const ::nebula::storage::cpp2::KVRemoveRequest& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("remove"); +} + +folly::SemiFuture< ::nebula::storage::cpp2::ExecResponse> GeneralStorageServiceSvIf::semifuture_remove(const ::nebula::storage::cpp2::KVRemoveRequest& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::storage::cpp2::ExecResponse& _return) { remove(_return, p_req); }); +} + +folly::Future< ::nebula::storage::cpp2::ExecResponse> GeneralStorageServiceSvIf::future_remove(const ::nebula::storage::cpp2::KVRemoveRequest& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_remove(p_req), std::move(ka)); +} + +void GeneralStorageServiceSvIf::async_tm_remove(std::unique_ptr> callback, const ::nebula::storage::cpp2::KVRemoveRequest& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_remove(p_req); + }); +} + +void GeneralStorageServiceSvNull::get( ::nebula::storage::cpp2::KVGetResponse& /*_return*/, const ::nebula::storage::cpp2::KVGetRequest& /*req*/) {} + +void GeneralStorageServiceSvNull::put( ::nebula::storage::cpp2::ExecResponse& /*_return*/, const ::nebula::storage::cpp2::KVPutRequest& /*req*/) {} + +void GeneralStorageServiceSvNull::remove( ::nebula::storage::cpp2::ExecResponse& /*_return*/, const ::nebula::storage::cpp2::KVRemoveRequest& /*req*/) {} + + + +const char* GeneralStorageServiceAsyncProcessor::getServiceName() { + return "GeneralStorageService"; +} + +void GeneralStorageServiceAsyncProcessor::getServiceMetadata(apache::thrift::metadata::ThriftServiceMetadataResponse& response) { + ::apache::thrift::detail::md::ServiceMetadata::gen(*response.metadata_ref(), *response.context_ref()); +} + +void GeneralStorageServiceAsyncProcessor::processSerializedRequest(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::protocol::PROTOCOL_TYPES protType, apache::thrift::Cpp2RequestContext* context, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + apache::thrift::detail::ap::process(this, std::move(req), std::move(serializedRequest), protType, context, eb, tm); +} + +std::shared_ptr GeneralStorageServiceAsyncProcessor::getBaseContextForRequest() { + return iface_->getBaseContextForRequest(); +} + +const GeneralStorageServiceAsyncProcessor::ProcessMap& GeneralStorageServiceAsyncProcessor::getBinaryProtocolProcessMap() { + return binaryProcessMap_; +} + +const GeneralStorageServiceAsyncProcessor::ProcessMap GeneralStorageServiceAsyncProcessor::binaryProcessMap_ { + {"get", &GeneralStorageServiceAsyncProcessor::setUpAndProcess_get}, + {"put", &GeneralStorageServiceAsyncProcessor::setUpAndProcess_put}, + {"remove", &GeneralStorageServiceAsyncProcessor::setUpAndProcess_remove}, +}; + +const GeneralStorageServiceAsyncProcessor::ProcessMap& GeneralStorageServiceAsyncProcessor::getCompactProtocolProcessMap() { + return compactProcessMap_; +} + +const GeneralStorageServiceAsyncProcessor::ProcessMap GeneralStorageServiceAsyncProcessor::compactProcessMap_ { + {"get", &GeneralStorageServiceAsyncProcessor::setUpAndProcess_get}, + {"put", &GeneralStorageServiceAsyncProcessor::setUpAndProcess_put}, + {"remove", &GeneralStorageServiceAsyncProcessor::setUpAndProcess_remove}, +}; + +}}} // nebula::storage::cpp2 diff --git a/src/interface/gen-cpp2/GeneralStorageService.h b/src/interface/gen-cpp2/GeneralStorageService.h new file mode 100644 index 00000000..f71501a4 --- /dev/null +++ b/src/interface/gen-cpp2/GeneralStorageService.h @@ -0,0 +1,123 @@ +/** + * Autogenerated by Thrift for storage.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#pragma once + +#include + +#include "GeneralStorageServiceAsyncClient.h" +#include "storage_types.h" +#include "common_types.h" +#include "meta_types.h" + +namespace folly { + class IOBuf; + class IOBufQueue; +} +namespace apache { namespace thrift { + class Cpp2RequestContext; + class BinaryProtocolReader; + class CompactProtocolReader; + namespace transport { class THeader; } +}} + +namespace nebula { namespace storage { namespace cpp2 { + +class GeneralStorageServiceSvAsyncIf { + public: + virtual ~GeneralStorageServiceSvAsyncIf() {} + virtual void async_tm_get(std::unique_ptr> callback, const ::nebula::storage::cpp2::KVGetRequest& p_req) = 0; + virtual folly::Future< ::nebula::storage::cpp2::KVGetResponse> future_get(const ::nebula::storage::cpp2::KVGetRequest& p_req) = 0; + virtual folly::SemiFuture< ::nebula::storage::cpp2::KVGetResponse> semifuture_get(const ::nebula::storage::cpp2::KVGetRequest& p_req) = 0; + virtual void async_tm_put(std::unique_ptr> callback, const ::nebula::storage::cpp2::KVPutRequest& p_req) = 0; + virtual folly::Future< ::nebula::storage::cpp2::ExecResponse> future_put(const ::nebula::storage::cpp2::KVPutRequest& p_req) = 0; + virtual folly::SemiFuture< ::nebula::storage::cpp2::ExecResponse> semifuture_put(const ::nebula::storage::cpp2::KVPutRequest& p_req) = 0; + virtual void async_tm_remove(std::unique_ptr> callback, const ::nebula::storage::cpp2::KVRemoveRequest& p_req) = 0; + virtual folly::Future< ::nebula::storage::cpp2::ExecResponse> future_remove(const ::nebula::storage::cpp2::KVRemoveRequest& p_req) = 0; + virtual folly::SemiFuture< ::nebula::storage::cpp2::ExecResponse> semifuture_remove(const ::nebula::storage::cpp2::KVRemoveRequest& p_req) = 0; +}; + +class GeneralStorageServiceAsyncProcessor; + +class GeneralStorageServiceSvIf : public GeneralStorageServiceSvAsyncIf, public apache::thrift::ServerInterface { + public: + typedef GeneralStorageServiceAsyncProcessor ProcessorType; + std::unique_ptr getProcessor() override; + + + virtual void get( ::nebula::storage::cpp2::KVGetResponse& /*_return*/, const ::nebula::storage::cpp2::KVGetRequest& /*req*/); + folly::Future< ::nebula::storage::cpp2::KVGetResponse> future_get(const ::nebula::storage::cpp2::KVGetRequest& p_req) override; + folly::SemiFuture< ::nebula::storage::cpp2::KVGetResponse> semifuture_get(const ::nebula::storage::cpp2::KVGetRequest& p_req) override; + void async_tm_get(std::unique_ptr> callback, const ::nebula::storage::cpp2::KVGetRequest& p_req) override; + virtual void put( ::nebula::storage::cpp2::ExecResponse& /*_return*/, const ::nebula::storage::cpp2::KVPutRequest& /*req*/); + folly::Future< ::nebula::storage::cpp2::ExecResponse> future_put(const ::nebula::storage::cpp2::KVPutRequest& p_req) override; + folly::SemiFuture< ::nebula::storage::cpp2::ExecResponse> semifuture_put(const ::nebula::storage::cpp2::KVPutRequest& p_req) override; + void async_tm_put(std::unique_ptr> callback, const ::nebula::storage::cpp2::KVPutRequest& p_req) override; + virtual void remove( ::nebula::storage::cpp2::ExecResponse& /*_return*/, const ::nebula::storage::cpp2::KVRemoveRequest& /*req*/); + folly::Future< ::nebula::storage::cpp2::ExecResponse> future_remove(const ::nebula::storage::cpp2::KVRemoveRequest& p_req) override; + folly::SemiFuture< ::nebula::storage::cpp2::ExecResponse> semifuture_remove(const ::nebula::storage::cpp2::KVRemoveRequest& p_req) override; + void async_tm_remove(std::unique_ptr> callback, const ::nebula::storage::cpp2::KVRemoveRequest& p_req) override; +}; + +class GeneralStorageServiceSvNull : public GeneralStorageServiceSvIf { + public: + void get( ::nebula::storage::cpp2::KVGetResponse& /*_return*/, const ::nebula::storage::cpp2::KVGetRequest& /*req*/) override; + void put( ::nebula::storage::cpp2::ExecResponse& /*_return*/, const ::nebula::storage::cpp2::KVPutRequest& /*req*/) override; + void remove( ::nebula::storage::cpp2::ExecResponse& /*_return*/, const ::nebula::storage::cpp2::KVRemoveRequest& /*req*/) override; +}; + +class GeneralStorageServiceAsyncProcessor : public ::apache::thrift::GeneratedAsyncProcessor { + public: + const char* getServiceName() override; + void getServiceMetadata(apache::thrift::metadata::ThriftServiceMetadataResponse& response) override; + using BaseAsyncProcessor = void; + protected: + GeneralStorageServiceSvIf* iface_; + public: + void processSerializedRequest(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::protocol::PROTOCOL_TYPES protType, apache::thrift::Cpp2RequestContext* context, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) override; + protected: + std::shared_ptr getBaseContextForRequest() override; + public: + using ProcessFunc = GeneratedAsyncProcessor::ProcessFunc; + using ProcessMap = GeneratedAsyncProcessor::ProcessMap; + static const GeneralStorageServiceAsyncProcessor::ProcessMap& getBinaryProtocolProcessMap(); + static const GeneralStorageServiceAsyncProcessor::ProcessMap& getCompactProtocolProcessMap(); + private: + static const GeneralStorageServiceAsyncProcessor::ProcessMap binaryProcessMap_; + static const GeneralStorageServiceAsyncProcessor::ProcessMap compactProcessMap_; + private: + template + void setUpAndProcess_get(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_get(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_get(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::storage::cpp2::KVGetResponse const& _return); + template + static void throw_wrapped_get(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_put(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_put(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_put(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::storage::cpp2::ExecResponse const& _return); + template + static void throw_wrapped_put(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_remove(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_remove(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_remove(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::storage::cpp2::ExecResponse const& _return); + template + static void throw_wrapped_remove(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + public: + GeneralStorageServiceAsyncProcessor(GeneralStorageServiceSvIf* iface) : + iface_(iface) {} + + virtual ~GeneralStorageServiceAsyncProcessor() {} +}; + +}}} // nebula::storage::cpp2 diff --git a/src/interface/gen-cpp2/GeneralStorageService.tcc b/src/interface/gen-cpp2/GeneralStorageService.tcc new file mode 100644 index 00000000..1bc0d59e --- /dev/null +++ b/src/interface/gen-cpp2/GeneralStorageService.tcc @@ -0,0 +1,192 @@ +/** + * Autogenerated by Thrift for storage.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#pragma once + +#include "GeneralStorageService.h" + +#include + +namespace nebula { namespace storage { namespace cpp2 { +typedef apache::thrift::ThriftPresult> GeneralStorageService_get_pargs; +typedef apache::thrift::ThriftPresult> GeneralStorageService_get_presult; +typedef apache::thrift::ThriftPresult> GeneralStorageService_put_pargs; +typedef apache::thrift::ThriftPresult> GeneralStorageService_put_presult; +typedef apache::thrift::ThriftPresult> GeneralStorageService_remove_pargs; +typedef apache::thrift::ThriftPresult> GeneralStorageService_remove_presult; +template +void GeneralStorageServiceAsyncProcessor::setUpAndProcess_get(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &GeneralStorageServiceAsyncProcessor::process_get, this); +} + +template +void GeneralStorageServiceAsyncProcessor::process_get(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + GeneralStorageService_get_pargs args; + ::nebula::storage::cpp2::KVGetRequest uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "GeneralStorageService.get", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "get"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_get, throw_wrapped_get, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_get(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue GeneralStorageServiceAsyncProcessor::return_get(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::storage::cpp2::KVGetResponse const& _return) { + ProtocolOut_ prot; + GeneralStorageService_get_presult result; + result.get<0>().value = const_cast< ::nebula::storage::cpp2::KVGetResponse*>(&_return); + result.setIsSet(0, true); + return serializeResponse("get", &prot, protoSeqId, ctx, result); +} + +template +void GeneralStorageServiceAsyncProcessor::throw_wrapped_get(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "get"); + return; + } +} + +template +void GeneralStorageServiceAsyncProcessor::setUpAndProcess_put(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &GeneralStorageServiceAsyncProcessor::process_put, this); +} + +template +void GeneralStorageServiceAsyncProcessor::process_put(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + GeneralStorageService_put_pargs args; + ::nebula::storage::cpp2::KVPutRequest uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "GeneralStorageService.put", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "put"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_put, throw_wrapped_put, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_put(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue GeneralStorageServiceAsyncProcessor::return_put(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::storage::cpp2::ExecResponse const& _return) { + ProtocolOut_ prot; + GeneralStorageService_put_presult result; + result.get<0>().value = const_cast< ::nebula::storage::cpp2::ExecResponse*>(&_return); + result.setIsSet(0, true); + return serializeResponse("put", &prot, protoSeqId, ctx, result); +} + +template +void GeneralStorageServiceAsyncProcessor::throw_wrapped_put(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "put"); + return; + } +} + +template +void GeneralStorageServiceAsyncProcessor::setUpAndProcess_remove(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &GeneralStorageServiceAsyncProcessor::process_remove, this); +} + +template +void GeneralStorageServiceAsyncProcessor::process_remove(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + GeneralStorageService_remove_pargs args; + ::nebula::storage::cpp2::KVRemoveRequest uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "GeneralStorageService.remove", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "remove"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_remove, throw_wrapped_remove, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_remove(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue GeneralStorageServiceAsyncProcessor::return_remove(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::storage::cpp2::ExecResponse const& _return) { + ProtocolOut_ prot; + GeneralStorageService_remove_presult result; + result.get<0>().value = const_cast< ::nebula::storage::cpp2::ExecResponse*>(&_return); + result.setIsSet(0, true); + return serializeResponse("remove", &prot, protoSeqId, ctx, result); +} + +template +void GeneralStorageServiceAsyncProcessor::throw_wrapped_remove(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "remove"); + return; + } +} + + +}}} // nebula::storage::cpp2 diff --git a/src/interface/gen-cpp2/GeneralStorageServiceAsyncClient.cpp b/src/interface/gen-cpp2/GeneralStorageServiceAsyncClient.cpp new file mode 100644 index 00000000..993d3a23 --- /dev/null +++ b/src/interface/gen-cpp2/GeneralStorageServiceAsyncClient.cpp @@ -0,0 +1,563 @@ +/** + * Autogenerated by Thrift for storage.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ + +#include "GeneralStorageServiceAsyncClient.h" + +#include + +namespace nebula { namespace storage { namespace cpp2 { +typedef apache::thrift::ThriftPresult> GeneralStorageService_get_pargs; +typedef apache::thrift::ThriftPresult> GeneralStorageService_get_presult; +typedef apache::thrift::ThriftPresult> GeneralStorageService_put_pargs; +typedef apache::thrift::ThriftPresult> GeneralStorageService_put_presult; +typedef apache::thrift::ThriftPresult> GeneralStorageService_remove_pargs; +typedef apache::thrift::ThriftPresult> GeneralStorageService_remove_presult; + +template +void GeneralStorageServiceAsyncClient::getT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::KVGetRequest& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + GeneralStorageService_get_pargs args; + args.get<0>().value = const_cast< ::nebula::storage::cpp2::KVGetRequest*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "get"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void GeneralStorageServiceAsyncClient::putT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::KVPutRequest& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + GeneralStorageService_put_pargs args; + args.get<0>().value = const_cast< ::nebula::storage::cpp2::KVPutRequest*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "put"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void GeneralStorageServiceAsyncClient::removeT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::KVRemoveRequest& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + GeneralStorageService_remove_pargs args; + args.get<0>().value = const_cast< ::nebula::storage::cpp2::KVRemoveRequest*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "remove"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + + + +void GeneralStorageServiceAsyncClient::get(std::unique_ptr callback, const ::nebula::storage::cpp2::KVGetRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + get(rpcOptions, std::move(callback), p_req); +} + +void GeneralStorageServiceAsyncClient::get(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::storage::cpp2::KVGetRequest& p_req) { + auto ctx = getCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + getImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void GeneralStorageServiceAsyncClient::getImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::KVGetRequest& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + getT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + getT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> GeneralStorageServiceAsyncClient::getCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "GeneralStorageService.get"); +} + +void GeneralStorageServiceAsyncClient::sync_get( ::nebula::storage::cpp2::KVGetResponse& _return, const ::nebula::storage::cpp2::KVGetRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_get(rpcOptions, _return, p_req); +} + +void GeneralStorageServiceAsyncClient::sync_get(apache::thrift::RpcOptions& rpcOptions, ::nebula::storage::cpp2::KVGetResponse& _return, const ::nebula::storage::cpp2::KVGetRequest& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = getCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + getImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_get(_return, returnState); + }); +} + + +folly::Future< ::nebula::storage::cpp2::KVGetResponse> GeneralStorageServiceAsyncClient::future_get(const ::nebula::storage::cpp2::KVGetRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_get(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::storage::cpp2::KVGetResponse> GeneralStorageServiceAsyncClient::semifuture_get(const ::nebula::storage::cpp2::KVGetRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_get(rpcOptions, p_req); +} + +folly::Future< ::nebula::storage::cpp2::KVGetResponse> GeneralStorageServiceAsyncClient::future_get(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::KVGetRequest& p_req) { + folly::Promise< ::nebula::storage::cpp2::KVGetResponse> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_get, channel_); + get(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::storage::cpp2::KVGetResponse> GeneralStorageServiceAsyncClient::semifuture_get(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::KVGetRequest& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_get, channel_); + auto callback = std::move(callbackAndFuture.first); + get(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> GeneralStorageServiceAsyncClient::header_future_get(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::KVGetRequest& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_get, channel_); + get(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> GeneralStorageServiceAsyncClient::header_semifuture_get(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::KVGetRequest& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_get, channel_); + auto callback = std::move(callbackAndFuture.first); + get(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void GeneralStorageServiceAsyncClient::get(folly::Function callback, const ::nebula::storage::cpp2::KVGetRequest& p_req) { + get(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper GeneralStorageServiceAsyncClient::recv_wrapped_get( ::nebula::storage::cpp2::KVGetResponse& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = GeneralStorageService_get_presult; + constexpr auto const fname = "get"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void GeneralStorageServiceAsyncClient::recv_get( ::nebula::storage::cpp2::KVGetResponse& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_get(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void GeneralStorageServiceAsyncClient::recv_instance_get( ::nebula::storage::cpp2::KVGetResponse& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_get(_return, state); +} + +folly::exception_wrapper GeneralStorageServiceAsyncClient::recv_instance_wrapped_get( ::nebula::storage::cpp2::KVGetResponse& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_get(_return, state); +} + +void GeneralStorageServiceAsyncClient::put(std::unique_ptr callback, const ::nebula::storage::cpp2::KVPutRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + put(rpcOptions, std::move(callback), p_req); +} + +void GeneralStorageServiceAsyncClient::put(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::storage::cpp2::KVPutRequest& p_req) { + auto ctx = putCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + putImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void GeneralStorageServiceAsyncClient::putImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::KVPutRequest& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + putT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + putT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> GeneralStorageServiceAsyncClient::putCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "GeneralStorageService.put"); +} + +void GeneralStorageServiceAsyncClient::sync_put( ::nebula::storage::cpp2::ExecResponse& _return, const ::nebula::storage::cpp2::KVPutRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_put(rpcOptions, _return, p_req); +} + +void GeneralStorageServiceAsyncClient::sync_put(apache::thrift::RpcOptions& rpcOptions, ::nebula::storage::cpp2::ExecResponse& _return, const ::nebula::storage::cpp2::KVPutRequest& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = putCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + putImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_put(_return, returnState); + }); +} + + +folly::Future< ::nebula::storage::cpp2::ExecResponse> GeneralStorageServiceAsyncClient::future_put(const ::nebula::storage::cpp2::KVPutRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_put(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::storage::cpp2::ExecResponse> GeneralStorageServiceAsyncClient::semifuture_put(const ::nebula::storage::cpp2::KVPutRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_put(rpcOptions, p_req); +} + +folly::Future< ::nebula::storage::cpp2::ExecResponse> GeneralStorageServiceAsyncClient::future_put(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::KVPutRequest& p_req) { + folly::Promise< ::nebula::storage::cpp2::ExecResponse> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_put, channel_); + put(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::storage::cpp2::ExecResponse> GeneralStorageServiceAsyncClient::semifuture_put(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::KVPutRequest& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_put, channel_); + auto callback = std::move(callbackAndFuture.first); + put(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> GeneralStorageServiceAsyncClient::header_future_put(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::KVPutRequest& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_put, channel_); + put(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> GeneralStorageServiceAsyncClient::header_semifuture_put(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::KVPutRequest& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_put, channel_); + auto callback = std::move(callbackAndFuture.first); + put(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void GeneralStorageServiceAsyncClient::put(folly::Function callback, const ::nebula::storage::cpp2::KVPutRequest& p_req) { + put(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper GeneralStorageServiceAsyncClient::recv_wrapped_put( ::nebula::storage::cpp2::ExecResponse& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = GeneralStorageService_put_presult; + constexpr auto const fname = "put"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void GeneralStorageServiceAsyncClient::recv_put( ::nebula::storage::cpp2::ExecResponse& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_put(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void GeneralStorageServiceAsyncClient::recv_instance_put( ::nebula::storage::cpp2::ExecResponse& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_put(_return, state); +} + +folly::exception_wrapper GeneralStorageServiceAsyncClient::recv_instance_wrapped_put( ::nebula::storage::cpp2::ExecResponse& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_put(_return, state); +} + +void GeneralStorageServiceAsyncClient::remove(std::unique_ptr callback, const ::nebula::storage::cpp2::KVRemoveRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + remove(rpcOptions, std::move(callback), p_req); +} + +void GeneralStorageServiceAsyncClient::remove(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::storage::cpp2::KVRemoveRequest& p_req) { + auto ctx = removeCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + removeImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void GeneralStorageServiceAsyncClient::removeImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::KVRemoveRequest& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + removeT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + removeT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> GeneralStorageServiceAsyncClient::removeCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "GeneralStorageService.remove"); +} + +void GeneralStorageServiceAsyncClient::sync_remove( ::nebula::storage::cpp2::ExecResponse& _return, const ::nebula::storage::cpp2::KVRemoveRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_remove(rpcOptions, _return, p_req); +} + +void GeneralStorageServiceAsyncClient::sync_remove(apache::thrift::RpcOptions& rpcOptions, ::nebula::storage::cpp2::ExecResponse& _return, const ::nebula::storage::cpp2::KVRemoveRequest& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = removeCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + removeImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_remove(_return, returnState); + }); +} + + +folly::Future< ::nebula::storage::cpp2::ExecResponse> GeneralStorageServiceAsyncClient::future_remove(const ::nebula::storage::cpp2::KVRemoveRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_remove(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::storage::cpp2::ExecResponse> GeneralStorageServiceAsyncClient::semifuture_remove(const ::nebula::storage::cpp2::KVRemoveRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_remove(rpcOptions, p_req); +} + +folly::Future< ::nebula::storage::cpp2::ExecResponse> GeneralStorageServiceAsyncClient::future_remove(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::KVRemoveRequest& p_req) { + folly::Promise< ::nebula::storage::cpp2::ExecResponse> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_remove, channel_); + remove(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::storage::cpp2::ExecResponse> GeneralStorageServiceAsyncClient::semifuture_remove(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::KVRemoveRequest& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_remove, channel_); + auto callback = std::move(callbackAndFuture.first); + remove(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> GeneralStorageServiceAsyncClient::header_future_remove(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::KVRemoveRequest& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_remove, channel_); + remove(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> GeneralStorageServiceAsyncClient::header_semifuture_remove(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::KVRemoveRequest& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_remove, channel_); + auto callback = std::move(callbackAndFuture.first); + remove(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void GeneralStorageServiceAsyncClient::remove(folly::Function callback, const ::nebula::storage::cpp2::KVRemoveRequest& p_req) { + remove(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper GeneralStorageServiceAsyncClient::recv_wrapped_remove( ::nebula::storage::cpp2::ExecResponse& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = GeneralStorageService_remove_presult; + constexpr auto const fname = "remove"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void GeneralStorageServiceAsyncClient::recv_remove( ::nebula::storage::cpp2::ExecResponse& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_remove(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void GeneralStorageServiceAsyncClient::recv_instance_remove( ::nebula::storage::cpp2::ExecResponse& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_remove(_return, state); +} + +folly::exception_wrapper GeneralStorageServiceAsyncClient::recv_instance_wrapped_remove( ::nebula::storage::cpp2::ExecResponse& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_remove(_return, state); +} + + +}}} // nebula::storage::cpp2 diff --git a/src/interface/gen-cpp2/GeneralStorageServiceAsyncClient.h b/src/interface/gen-cpp2/GeneralStorageServiceAsyncClient.h new file mode 100644 index 00000000..409613c4 --- /dev/null +++ b/src/interface/gen-cpp2/GeneralStorageServiceAsyncClient.h @@ -0,0 +1,280 @@ +/** + * Autogenerated by Thrift for storage.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#pragma once + +#include + +#include "storage_types.h" +#include "common_types.h" +#include "meta_types.h" + +namespace apache { namespace thrift { + class Cpp2RequestContext; + namespace detail { namespace ac { struct ClientRequestContext; }} + namespace transport { class THeader; } +}} + +namespace nebula { namespace storage { namespace cpp2 { + +class GeneralStorageServiceAsyncClient : public apache::thrift::GeneratedAsyncClient { + public: + using apache::thrift::GeneratedAsyncClient::GeneratedAsyncClient; + + char const* getServiceName() const noexcept override { + return "GeneralStorageService"; + } + + + virtual void get(std::unique_ptr callback, const ::nebula::storage::cpp2::KVGetRequest& p_req); + virtual void get(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::storage::cpp2::KVGetRequest& p_req); + protected: + void getImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::KVGetRequest& p_req); + public: + + virtual void sync_get( ::nebula::storage::cpp2::KVGetResponse& _return, const ::nebula::storage::cpp2::KVGetRequest& p_req); + virtual void sync_get(apache::thrift::RpcOptions& rpcOptions, ::nebula::storage::cpp2::KVGetResponse& _return, const ::nebula::storage::cpp2::KVGetRequest& p_req); + + virtual folly::Future< ::nebula::storage::cpp2::KVGetResponse> future_get(const ::nebula::storage::cpp2::KVGetRequest& p_req); + virtual folly::SemiFuture< ::nebula::storage::cpp2::KVGetResponse> semifuture_get(const ::nebula::storage::cpp2::KVGetRequest& p_req); + virtual folly::Future< ::nebula::storage::cpp2::KVGetResponse> future_get(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::KVGetRequest& p_req); + virtual folly::SemiFuture< ::nebula::storage::cpp2::KVGetResponse> semifuture_get(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::KVGetRequest& p_req); + virtual folly::Future>> header_future_get(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::KVGetRequest& p_req); + virtual folly::SemiFuture>> header_semifuture_get(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::KVGetRequest& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::storage::cpp2::KVGetResponse> co_get(const ::nebula::storage::cpp2::KVGetRequest& p_req) { + return co_get(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::storage::cpp2::KVGetResponse> co_get(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::KVGetRequest& p_req) { + return co_get(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::storage::cpp2::KVGetResponse> co_get(apache::thrift::RpcOptions* rpcOptions, const ::nebula::storage::cpp2::KVGetRequest& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = getCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + getImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + getImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::storage::cpp2::KVGetResponse _return; + if (auto ew = recv_wrapped_get(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void get(folly::Function callback, const ::nebula::storage::cpp2::KVGetRequest& p_req); + + + static folly::exception_wrapper recv_wrapped_get( ::nebula::storage::cpp2::KVGetResponse& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_get( ::nebula::storage::cpp2::KVGetResponse& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_get( ::nebula::storage::cpp2::KVGetResponse& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_get( ::nebula::storage::cpp2::KVGetResponse& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void getT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::KVGetRequest& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> getCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void put(std::unique_ptr callback, const ::nebula::storage::cpp2::KVPutRequest& p_req); + virtual void put(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::storage::cpp2::KVPutRequest& p_req); + protected: + void putImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::KVPutRequest& p_req); + public: + + virtual void sync_put( ::nebula::storage::cpp2::ExecResponse& _return, const ::nebula::storage::cpp2::KVPutRequest& p_req); + virtual void sync_put(apache::thrift::RpcOptions& rpcOptions, ::nebula::storage::cpp2::ExecResponse& _return, const ::nebula::storage::cpp2::KVPutRequest& p_req); + + virtual folly::Future< ::nebula::storage::cpp2::ExecResponse> future_put(const ::nebula::storage::cpp2::KVPutRequest& p_req); + virtual folly::SemiFuture< ::nebula::storage::cpp2::ExecResponse> semifuture_put(const ::nebula::storage::cpp2::KVPutRequest& p_req); + virtual folly::Future< ::nebula::storage::cpp2::ExecResponse> future_put(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::KVPutRequest& p_req); + virtual folly::SemiFuture< ::nebula::storage::cpp2::ExecResponse> semifuture_put(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::KVPutRequest& p_req); + virtual folly::Future>> header_future_put(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::KVPutRequest& p_req); + virtual folly::SemiFuture>> header_semifuture_put(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::KVPutRequest& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::storage::cpp2::ExecResponse> co_put(const ::nebula::storage::cpp2::KVPutRequest& p_req) { + return co_put(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::storage::cpp2::ExecResponse> co_put(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::KVPutRequest& p_req) { + return co_put(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::storage::cpp2::ExecResponse> co_put(apache::thrift::RpcOptions* rpcOptions, const ::nebula::storage::cpp2::KVPutRequest& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = putCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + putImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + putImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::storage::cpp2::ExecResponse _return; + if (auto ew = recv_wrapped_put(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void put(folly::Function callback, const ::nebula::storage::cpp2::KVPutRequest& p_req); + + + static folly::exception_wrapper recv_wrapped_put( ::nebula::storage::cpp2::ExecResponse& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_put( ::nebula::storage::cpp2::ExecResponse& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_put( ::nebula::storage::cpp2::ExecResponse& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_put( ::nebula::storage::cpp2::ExecResponse& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void putT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::KVPutRequest& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> putCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void remove(std::unique_ptr callback, const ::nebula::storage::cpp2::KVRemoveRequest& p_req); + virtual void remove(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::storage::cpp2::KVRemoveRequest& p_req); + protected: + void removeImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::KVRemoveRequest& p_req); + public: + + virtual void sync_remove( ::nebula::storage::cpp2::ExecResponse& _return, const ::nebula::storage::cpp2::KVRemoveRequest& p_req); + virtual void sync_remove(apache::thrift::RpcOptions& rpcOptions, ::nebula::storage::cpp2::ExecResponse& _return, const ::nebula::storage::cpp2::KVRemoveRequest& p_req); + + virtual folly::Future< ::nebula::storage::cpp2::ExecResponse> future_remove(const ::nebula::storage::cpp2::KVRemoveRequest& p_req); + virtual folly::SemiFuture< ::nebula::storage::cpp2::ExecResponse> semifuture_remove(const ::nebula::storage::cpp2::KVRemoveRequest& p_req); + virtual folly::Future< ::nebula::storage::cpp2::ExecResponse> future_remove(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::KVRemoveRequest& p_req); + virtual folly::SemiFuture< ::nebula::storage::cpp2::ExecResponse> semifuture_remove(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::KVRemoveRequest& p_req); + virtual folly::Future>> header_future_remove(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::KVRemoveRequest& p_req); + virtual folly::SemiFuture>> header_semifuture_remove(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::KVRemoveRequest& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::storage::cpp2::ExecResponse> co_remove(const ::nebula::storage::cpp2::KVRemoveRequest& p_req) { + return co_remove(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::storage::cpp2::ExecResponse> co_remove(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::KVRemoveRequest& p_req) { + return co_remove(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::storage::cpp2::ExecResponse> co_remove(apache::thrift::RpcOptions* rpcOptions, const ::nebula::storage::cpp2::KVRemoveRequest& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = removeCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + removeImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + removeImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::storage::cpp2::ExecResponse _return; + if (auto ew = recv_wrapped_remove(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void remove(folly::Function callback, const ::nebula::storage::cpp2::KVRemoveRequest& p_req); + + + static folly::exception_wrapper recv_wrapped_remove( ::nebula::storage::cpp2::ExecResponse& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_remove( ::nebula::storage::cpp2::ExecResponse& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_remove( ::nebula::storage::cpp2::ExecResponse& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_remove( ::nebula::storage::cpp2::ExecResponse& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void removeT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::KVRemoveRequest& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> removeCtx(apache::thrift::RpcOptions* rpcOptions); + public: +}; + +}}} // nebula::storage::cpp2 diff --git a/src/interface/gen-cpp2/GeneralStorageService_custom_protocol.h b/src/interface/gen-cpp2/GeneralStorageService_custom_protocol.h new file mode 100644 index 00000000..244c03c0 --- /dev/null +++ b/src/interface/gen-cpp2/GeneralStorageService_custom_protocol.h @@ -0,0 +1,19 @@ +/** + * Autogenerated by Thrift for storage.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#pragma once + +/** + * This header file includes the tcc files of the corresponding header file + * and the header files of its dependent types. Include this header file + * only when you need to use custom protocols (e.g. DebugProtocol, + * VirtualProtocol) to read/write thrift structs. + */ + +#include "GeneralStorageService.tcc" +#include "storage_types_custom_protocol.h" +#include "common_types_custom_protocol.h" +#include "meta_types_custom_protocol.h" diff --git a/src/interface/gen-cpp2/GeneralStorageService_processmap_binary.cpp b/src/interface/gen-cpp2/GeneralStorageService_processmap_binary.cpp new file mode 100644 index 00000000..f2bf1d45 --- /dev/null +++ b/src/interface/gen-cpp2/GeneralStorageService_processmap_binary.cpp @@ -0,0 +1,12 @@ +/** + * Autogenerated by Thrift for storage.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ + +#include "GeneralStorageService.h" +#include "GeneralStorageService.tcc" + +namespace nebula { namespace storage { namespace cpp2 { +}}} // nebula::storage::cpp2 diff --git a/src/interface/gen-cpp2/GeneralStorageService_processmap_compact.cpp b/src/interface/gen-cpp2/GeneralStorageService_processmap_compact.cpp new file mode 100644 index 00000000..f2bf1d45 --- /dev/null +++ b/src/interface/gen-cpp2/GeneralStorageService_processmap_compact.cpp @@ -0,0 +1,12 @@ +/** + * Autogenerated by Thrift for storage.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ + +#include "GeneralStorageService.h" +#include "GeneralStorageService.tcc" + +namespace nebula { namespace storage { namespace cpp2 { +}}} // nebula::storage::cpp2 diff --git a/src/interface/gen-cpp2/GraphService.cpp b/src/interface/gen-cpp2/GraphService.cpp new file mode 100644 index 00000000..bd293ea3 --- /dev/null +++ b/src/interface/gen-cpp2/GraphService.cpp @@ -0,0 +1,179 @@ +/** + * Autogenerated by Thrift for graph.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#include "GraphService.h" +#include "GraphService.tcc" +#include "graph_metadata.h" +#include + +namespace nebula { namespace graph { namespace cpp2 { +std::unique_ptr GraphServiceSvIf::getProcessor() { + return std::make_unique(this); +} + + +void GraphServiceSvIf::authenticate(nebula::AuthResponse& /*_return*/, const ::std::string& /*username*/, const ::std::string& /*password*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("authenticate"); +} + +folly::SemiFuture GraphServiceSvIf::semifuture_authenticate(const ::std::string& p_username, const ::std::string& p_password) { + return apache::thrift::detail::si::semifuture_returning([&](nebula::AuthResponse& _return) { authenticate(_return, p_username, p_password); }); +} + +folly::Future GraphServiceSvIf::future_authenticate(const ::std::string& p_username, const ::std::string& p_password) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_authenticate(p_username, p_password), std::move(ka)); +} + +void GraphServiceSvIf::async_tm_authenticate(std::unique_ptr> callback, const ::std::string& p_username, const ::std::string& p_password) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_authenticate(p_username, p_password); + }); +} + +void GraphServiceSvIf::signout(int64_t /*sessionId*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("signout"); +} + +folly::SemiFuture GraphServiceSvIf::semifuture_signout(int64_t p_sessionId) { + return apache::thrift::detail::si::semifuture([&] { + return signout(p_sessionId); + }); +} + +folly::Future GraphServiceSvIf::future_signout(int64_t p_sessionId) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_signout(p_sessionId), std::move(ka)); +} + +void GraphServiceSvIf::async_tm_signout(std::unique_ptr callback, int64_t p_sessionId) { + apache::thrift::detail::si::async_tm_oneway(this, std::move(callback), [&] { + return future_signout(p_sessionId); + }); +} + +void GraphServiceSvIf::execute(nebula::ExecutionResponse& /*_return*/, int64_t /*sessionId*/, const ::std::string& /*stmt*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("execute"); +} + +folly::SemiFuture GraphServiceSvIf::semifuture_execute(int64_t p_sessionId, const ::std::string& p_stmt) { + return apache::thrift::detail::si::semifuture_returning([&](nebula::ExecutionResponse& _return) { execute(_return, p_sessionId, p_stmt); }); +} + +folly::Future GraphServiceSvIf::future_execute(int64_t p_sessionId, const ::std::string& p_stmt) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_execute(p_sessionId, p_stmt), std::move(ka)); +} + +void GraphServiceSvIf::async_tm_execute(std::unique_ptr> callback, int64_t p_sessionId, const ::std::string& p_stmt) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_execute(p_sessionId, p_stmt); + }); +} + +void GraphServiceSvIf::executeJson(::std::string& /*_return*/, int64_t /*sessionId*/, const ::std::string& /*stmt*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("executeJson"); +} + +folly::SemiFuture<::std::string> GraphServiceSvIf::semifuture_executeJson(int64_t p_sessionId, const ::std::string& p_stmt) { + return apache::thrift::detail::si::semifuture_returning([&](::std::string& _return) { executeJson(_return, p_sessionId, p_stmt); }); +} + +folly::Future<::std::string> GraphServiceSvIf::future_executeJson(int64_t p_sessionId, const ::std::string& p_stmt) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_executeJson(p_sessionId, p_stmt), std::move(ka)); +} + +void GraphServiceSvIf::async_tm_executeJson(std::unique_ptr> callback, int64_t p_sessionId, const ::std::string& p_stmt) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_executeJson(p_sessionId, p_stmt); + }); +} + +void GraphServiceSvIf::verifyClientVersion( ::nebula::graph::cpp2::VerifyClientVersionResp& /*_return*/, const ::nebula::graph::cpp2::VerifyClientVersionReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("verifyClientVersion"); +} + +folly::SemiFuture< ::nebula::graph::cpp2::VerifyClientVersionResp> GraphServiceSvIf::semifuture_verifyClientVersion(const ::nebula::graph::cpp2::VerifyClientVersionReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::graph::cpp2::VerifyClientVersionResp& _return) { verifyClientVersion(_return, p_req); }); +} + +folly::Future< ::nebula::graph::cpp2::VerifyClientVersionResp> GraphServiceSvIf::future_verifyClientVersion(const ::nebula::graph::cpp2::VerifyClientVersionReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_verifyClientVersion(p_req), std::move(ka)); +} + +void GraphServiceSvIf::async_tm_verifyClientVersion(std::unique_ptr> callback, const ::nebula::graph::cpp2::VerifyClientVersionReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_verifyClientVersion(p_req); + }); +} + +void GraphServiceSvNull::authenticate(nebula::AuthResponse& /*_return*/, const ::std::string& /*username*/, const ::std::string& /*password*/) {} + +void GraphServiceSvNull::signout(int64_t /*sessionId*/) { + return; +} + +void GraphServiceSvNull::execute(nebula::ExecutionResponse& /*_return*/, int64_t /*sessionId*/, const ::std::string& /*stmt*/) {} + +void GraphServiceSvNull::executeJson(::std::string& /*_return*/, int64_t /*sessionId*/, const ::std::string& /*stmt*/) {} + +void GraphServiceSvNull::verifyClientVersion( ::nebula::graph::cpp2::VerifyClientVersionResp& /*_return*/, const ::nebula::graph::cpp2::VerifyClientVersionReq& /*req*/) {} + + + +const char* GraphServiceAsyncProcessor::getServiceName() { + return "GraphService"; +} + +void GraphServiceAsyncProcessor::getServiceMetadata(apache::thrift::metadata::ThriftServiceMetadataResponse& response) { + ::apache::thrift::detail::md::ServiceMetadata::gen(*response.metadata_ref(), *response.context_ref()); +} + +void GraphServiceAsyncProcessor::processSerializedRequest(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::protocol::PROTOCOL_TYPES protType, apache::thrift::Cpp2RequestContext* context, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + apache::thrift::detail::ap::process(this, std::move(req), std::move(serializedRequest), protType, context, eb, tm); +} + +std::shared_ptr GraphServiceAsyncProcessor::getBaseContextForRequest() { + return iface_->getBaseContextForRequest(); +} + +const GraphServiceAsyncProcessor::ProcessMap& GraphServiceAsyncProcessor::getBinaryProtocolProcessMap() { + return binaryProcessMap_; +} + +const GraphServiceAsyncProcessor::ProcessMap GraphServiceAsyncProcessor::binaryProcessMap_ { + {"authenticate", &GraphServiceAsyncProcessor::setUpAndProcess_authenticate}, + {"signout", &GraphServiceAsyncProcessor::setUpAndProcess_signout}, + {"execute", &GraphServiceAsyncProcessor::setUpAndProcess_execute}, + {"executeJson", &GraphServiceAsyncProcessor::setUpAndProcess_executeJson}, + {"verifyClientVersion", &GraphServiceAsyncProcessor::setUpAndProcess_verifyClientVersion}, +}; + +const GraphServiceAsyncProcessor::ProcessMap& GraphServiceAsyncProcessor::getCompactProtocolProcessMap() { + return compactProcessMap_; +} + +const GraphServiceAsyncProcessor::ProcessMap GraphServiceAsyncProcessor::compactProcessMap_ { + {"authenticate", &GraphServiceAsyncProcessor::setUpAndProcess_authenticate}, + {"signout", &GraphServiceAsyncProcessor::setUpAndProcess_signout}, + {"execute", &GraphServiceAsyncProcessor::setUpAndProcess_execute}, + {"executeJson", &GraphServiceAsyncProcessor::setUpAndProcess_executeJson}, + {"verifyClientVersion", &GraphServiceAsyncProcessor::setUpAndProcess_verifyClientVersion}, +}; + +}}} // nebula::graph::cpp2 diff --git a/src/interface/gen-cpp2/GraphService.h b/src/interface/gen-cpp2/GraphService.h new file mode 100644 index 00000000..205872ca --- /dev/null +++ b/src/interface/gen-cpp2/GraphService.h @@ -0,0 +1,157 @@ +/** + * Autogenerated by Thrift for graph.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#pragma once + +#include + +#include "GraphServiceAsyncClient.h" +#include "graph_types.h" +#include "common_types.h" +#include "common/graph/PairOps-inl.h" +#include "common/graph/ProfilingStatsOps-inl.h" +#include "common/graph/PlanNodeBranchInfoOps-inl.h" +#include "common/graph/PlanNodeDescriptionOps-inl.h" +#include "common/graph/PlanDescriptionOps-inl.h" +#include "common/graph/ExecutionResponseOps-inl.h" +#include "common/graph/AuthResponseOps-inl.h" + +namespace folly { + class IOBuf; + class IOBufQueue; +} +namespace apache { namespace thrift { + class Cpp2RequestContext; + class BinaryProtocolReader; + class CompactProtocolReader; + namespace transport { class THeader; } +}} + +namespace nebula { namespace graph { namespace cpp2 { + +class GraphServiceSvAsyncIf { + public: + virtual ~GraphServiceSvAsyncIf() {} + virtual void async_tm_authenticate(std::unique_ptr> callback, const ::std::string& p_username, const ::std::string& p_password) = 0; + virtual folly::Future future_authenticate(const ::std::string& p_username, const ::std::string& p_password) = 0; + virtual folly::SemiFuture semifuture_authenticate(const ::std::string& p_username, const ::std::string& p_password) = 0; + virtual void async_tm_signout(std::unique_ptr callback, int64_t p_sessionId) = 0; + virtual folly::Future future_signout(int64_t p_sessionId) = 0; + virtual folly::SemiFuture semifuture_signout(int64_t p_sessionId) = 0; + virtual void async_tm_execute(std::unique_ptr> callback, int64_t p_sessionId, const ::std::string& p_stmt) = 0; + virtual folly::Future future_execute(int64_t p_sessionId, const ::std::string& p_stmt) = 0; + virtual folly::SemiFuture semifuture_execute(int64_t p_sessionId, const ::std::string& p_stmt) = 0; + virtual void async_tm_executeJson(std::unique_ptr> callback, int64_t p_sessionId, const ::std::string& p_stmt) = 0; + virtual folly::Future<::std::string> future_executeJson(int64_t p_sessionId, const ::std::string& p_stmt) = 0; + virtual folly::SemiFuture<::std::string> semifuture_executeJson(int64_t p_sessionId, const ::std::string& p_stmt) = 0; + virtual void async_tm_verifyClientVersion(std::unique_ptr> callback, const ::nebula::graph::cpp2::VerifyClientVersionReq& p_req) = 0; + virtual folly::Future< ::nebula::graph::cpp2::VerifyClientVersionResp> future_verifyClientVersion(const ::nebula::graph::cpp2::VerifyClientVersionReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::graph::cpp2::VerifyClientVersionResp> semifuture_verifyClientVersion(const ::nebula::graph::cpp2::VerifyClientVersionReq& p_req) = 0; +}; + +class GraphServiceAsyncProcessor; + +class GraphServiceSvIf : public GraphServiceSvAsyncIf, public apache::thrift::ServerInterface { + public: + typedef GraphServiceAsyncProcessor ProcessorType; + std::unique_ptr getProcessor() override; + + + virtual void authenticate(nebula::AuthResponse& /*_return*/, const ::std::string& /*username*/, const ::std::string& /*password*/); + folly::Future future_authenticate(const ::std::string& p_username, const ::std::string& p_password) override; + folly::SemiFuture semifuture_authenticate(const ::std::string& p_username, const ::std::string& p_password) override; + void async_tm_authenticate(std::unique_ptr> callback, const ::std::string& p_username, const ::std::string& p_password) override; + virtual void signout(int64_t /*sessionId*/); + folly::Future future_signout(int64_t p_sessionId) override; + folly::SemiFuture semifuture_signout(int64_t p_sessionId) override; + void async_tm_signout(std::unique_ptr callback, int64_t p_sessionId) override; + virtual void execute(nebula::ExecutionResponse& /*_return*/, int64_t /*sessionId*/, const ::std::string& /*stmt*/); + folly::Future future_execute(int64_t p_sessionId, const ::std::string& p_stmt) override; + folly::SemiFuture semifuture_execute(int64_t p_sessionId, const ::std::string& p_stmt) override; + void async_tm_execute(std::unique_ptr> callback, int64_t p_sessionId, const ::std::string& p_stmt) override; + virtual void executeJson(::std::string& /*_return*/, int64_t /*sessionId*/, const ::std::string& /*stmt*/); + folly::Future<::std::string> future_executeJson(int64_t p_sessionId, const ::std::string& p_stmt) override; + folly::SemiFuture<::std::string> semifuture_executeJson(int64_t p_sessionId, const ::std::string& p_stmt) override; + void async_tm_executeJson(std::unique_ptr> callback, int64_t p_sessionId, const ::std::string& p_stmt) override; + virtual void verifyClientVersion( ::nebula::graph::cpp2::VerifyClientVersionResp& /*_return*/, const ::nebula::graph::cpp2::VerifyClientVersionReq& /*req*/); + folly::Future< ::nebula::graph::cpp2::VerifyClientVersionResp> future_verifyClientVersion(const ::nebula::graph::cpp2::VerifyClientVersionReq& p_req) override; + folly::SemiFuture< ::nebula::graph::cpp2::VerifyClientVersionResp> semifuture_verifyClientVersion(const ::nebula::graph::cpp2::VerifyClientVersionReq& p_req) override; + void async_tm_verifyClientVersion(std::unique_ptr> callback, const ::nebula::graph::cpp2::VerifyClientVersionReq& p_req) override; +}; + +class GraphServiceSvNull : public GraphServiceSvIf { + public: + void authenticate(nebula::AuthResponse& /*_return*/, const ::std::string& /*username*/, const ::std::string& /*password*/) override; + void signout(int64_t /*sessionId*/) override; + void execute(nebula::ExecutionResponse& /*_return*/, int64_t /*sessionId*/, const ::std::string& /*stmt*/) override; + void executeJson(::std::string& /*_return*/, int64_t /*sessionId*/, const ::std::string& /*stmt*/) override; + void verifyClientVersion( ::nebula::graph::cpp2::VerifyClientVersionResp& /*_return*/, const ::nebula::graph::cpp2::VerifyClientVersionReq& /*req*/) override; +}; + +class GraphServiceAsyncProcessor : public ::apache::thrift::GeneratedAsyncProcessor { + public: + const char* getServiceName() override; + void getServiceMetadata(apache::thrift::metadata::ThriftServiceMetadataResponse& response) override; + using BaseAsyncProcessor = void; + protected: + GraphServiceSvIf* iface_; + public: + void processSerializedRequest(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::protocol::PROTOCOL_TYPES protType, apache::thrift::Cpp2RequestContext* context, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) override; + protected: + std::shared_ptr getBaseContextForRequest() override; + public: + using ProcessFunc = GeneratedAsyncProcessor::ProcessFunc; + using ProcessMap = GeneratedAsyncProcessor::ProcessMap; + static const GraphServiceAsyncProcessor::ProcessMap& getBinaryProtocolProcessMap(); + static const GraphServiceAsyncProcessor::ProcessMap& getCompactProtocolProcessMap(); + private: + static const GraphServiceAsyncProcessor::ProcessMap binaryProcessMap_; + static const GraphServiceAsyncProcessor::ProcessMap compactProcessMap_; + private: + template + void setUpAndProcess_authenticate(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_authenticate(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_authenticate(int32_t protoSeqId, apache::thrift::ContextStack* ctx, nebula::AuthResponse const& _return); + template + static void throw_wrapped_authenticate(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_signout(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_signout(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void setUpAndProcess_execute(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_execute(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_execute(int32_t protoSeqId, apache::thrift::ContextStack* ctx, nebula::ExecutionResponse const& _return); + template + static void throw_wrapped_execute(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_executeJson(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_executeJson(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_executeJson(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::std::string const& _return); + template + static void throw_wrapped_executeJson(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_verifyClientVersion(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_verifyClientVersion(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_verifyClientVersion(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::graph::cpp2::VerifyClientVersionResp const& _return); + template + static void throw_wrapped_verifyClientVersion(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + public: + GraphServiceAsyncProcessor(GraphServiceSvIf* iface) : + iface_(iface) {} + + virtual ~GraphServiceAsyncProcessor() {} +}; + +}}} // nebula::graph::cpp2 diff --git a/src/interface/gen-cpp2/GraphService.tcc b/src/interface/gen-cpp2/GraphService.tcc new file mode 100644 index 00000000..499ec1d4 --- /dev/null +++ b/src/interface/gen-cpp2/GraphService.tcc @@ -0,0 +1,289 @@ +/** + * Autogenerated by Thrift for graph.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#pragma once + +#include "GraphService.h" + +#include + +namespace nebula { namespace graph { namespace cpp2 { +typedef apache::thrift::ThriftPresult, apache::thrift::FieldData<2, ::apache::thrift::type_class::binary, ::std::string*>> GraphService_authenticate_pargs; +typedef apache::thrift::ThriftPresult> GraphService_authenticate_presult; +typedef apache::thrift::ThriftPresult> GraphService_signout_pargs; +typedef apache::thrift::ThriftPresult, apache::thrift::FieldData<2, ::apache::thrift::type_class::binary, ::std::string*>> GraphService_execute_pargs; +typedef apache::thrift::ThriftPresult> GraphService_execute_presult; +typedef apache::thrift::ThriftPresult, apache::thrift::FieldData<2, ::apache::thrift::type_class::binary, ::std::string*>> GraphService_executeJson_pargs; +typedef apache::thrift::ThriftPresult> GraphService_executeJson_presult; +typedef apache::thrift::ThriftPresult> GraphService_verifyClientVersion_pargs; +typedef apache::thrift::ThriftPresult> GraphService_verifyClientVersion_presult; +template +void GraphServiceAsyncProcessor::setUpAndProcess_authenticate(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &GraphServiceAsyncProcessor::process_authenticate, this); +} + +template +void GraphServiceAsyncProcessor::process_authenticate(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + GraphService_authenticate_pargs args; + ::std::string uarg_username; + args.get<0>().value = &uarg_username; + ::std::string uarg_password; + args.get<1>().value = &uarg_password; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "GraphService.authenticate", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "authenticate"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_authenticate, throw_wrapped_authenticate, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_authenticate(std::move(callback), args.get<0>().ref(), args.get<1>().ref()); +} + +template +folly::IOBufQueue GraphServiceAsyncProcessor::return_authenticate(int32_t protoSeqId, apache::thrift::ContextStack* ctx, nebula::AuthResponse const& _return) { + ProtocolOut_ prot; + GraphService_authenticate_presult result; + result.get<0>().value = const_cast(&_return); + result.setIsSet(0, true); + return serializeResponse("authenticate", &prot, protoSeqId, ctx, result); +} + +template +void GraphServiceAsyncProcessor::throw_wrapped_authenticate(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "authenticate"); + return; + } +} + +template +void GraphServiceAsyncProcessor::setUpAndProcess_signout(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_NO_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_NO_RESPONSE, &GraphServiceAsyncProcessor::process_signout, this); +} + +template +void GraphServiceAsyncProcessor::process_signout(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + GraphService_signout_pargs args; + int64_t uarg_sessionId{0}; + args.get<0>().value = &uarg_sessionId; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "GraphService.signout", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + LOG(ERROR) << ex.what() << " in function signout"; + eb->runInEventBaseThread([req = std::move(req)] {}); + return; + } + auto callback = std::make_unique(std::move(req), std::move(ctxStack), nullptr, eb, tm, ctx); + iface_->async_tm_signout(std::move(callback), args.get<0>().ref()); +} + +template +void GraphServiceAsyncProcessor::setUpAndProcess_execute(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &GraphServiceAsyncProcessor::process_execute, this); +} + +template +void GraphServiceAsyncProcessor::process_execute(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + GraphService_execute_pargs args; + int64_t uarg_sessionId{0}; + args.get<0>().value = &uarg_sessionId; + ::std::string uarg_stmt; + args.get<1>().value = &uarg_stmt; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "GraphService.execute", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "execute"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_execute, throw_wrapped_execute, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_execute(std::move(callback), args.get<0>().ref(), args.get<1>().ref()); +} + +template +folly::IOBufQueue GraphServiceAsyncProcessor::return_execute(int32_t protoSeqId, apache::thrift::ContextStack* ctx, nebula::ExecutionResponse const& _return) { + ProtocolOut_ prot; + GraphService_execute_presult result; + result.get<0>().value = const_cast(&_return); + result.setIsSet(0, true); + return serializeResponse("execute", &prot, protoSeqId, ctx, result); +} + +template +void GraphServiceAsyncProcessor::throw_wrapped_execute(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "execute"); + return; + } +} + +template +void GraphServiceAsyncProcessor::setUpAndProcess_executeJson(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &GraphServiceAsyncProcessor::process_executeJson, this); +} + +template +void GraphServiceAsyncProcessor::process_executeJson(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + GraphService_executeJson_pargs args; + int64_t uarg_sessionId{0}; + args.get<0>().value = &uarg_sessionId; + ::std::string uarg_stmt; + args.get<1>().value = &uarg_stmt; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "GraphService.executeJson", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "executeJson"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_executeJson, throw_wrapped_executeJson, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_executeJson(std::move(callback), args.get<0>().ref(), args.get<1>().ref()); +} + +template +folly::IOBufQueue GraphServiceAsyncProcessor::return_executeJson(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::std::string const& _return) { + ProtocolOut_ prot; + GraphService_executeJson_presult result; + result.get<0>().value = const_cast<::std::string*>(&_return); + result.setIsSet(0, true); + return serializeResponse("executeJson", &prot, protoSeqId, ctx, result); +} + +template +void GraphServiceAsyncProcessor::throw_wrapped_executeJson(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "executeJson"); + return; + } +} + +template +void GraphServiceAsyncProcessor::setUpAndProcess_verifyClientVersion(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &GraphServiceAsyncProcessor::process_verifyClientVersion, this); +} + +template +void GraphServiceAsyncProcessor::process_verifyClientVersion(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + GraphService_verifyClientVersion_pargs args; + ::nebula::graph::cpp2::VerifyClientVersionReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "GraphService.verifyClientVersion", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "verifyClientVersion"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_verifyClientVersion, throw_wrapped_verifyClientVersion, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_verifyClientVersion(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue GraphServiceAsyncProcessor::return_verifyClientVersion(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::graph::cpp2::VerifyClientVersionResp const& _return) { + ProtocolOut_ prot; + GraphService_verifyClientVersion_presult result; + result.get<0>().value = const_cast< ::nebula::graph::cpp2::VerifyClientVersionResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("verifyClientVersion", &prot, protoSeqId, ctx, result); +} + +template +void GraphServiceAsyncProcessor::throw_wrapped_verifyClientVersion(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "verifyClientVersion"); + return; + } +} + + +}}} // nebula::graph::cpp2 diff --git a/src/interface/gen-cpp2/GraphServiceAsyncClient.cpp b/src/interface/gen-cpp2/GraphServiceAsyncClient.cpp new file mode 100644 index 00000000..7cb3a553 --- /dev/null +++ b/src/interface/gen-cpp2/GraphServiceAsyncClient.cpp @@ -0,0 +1,860 @@ +/** + * Autogenerated by Thrift for graph.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ + +#include "GraphServiceAsyncClient.h" + +#include + +namespace nebula { namespace graph { namespace cpp2 { +typedef apache::thrift::ThriftPresult, apache::thrift::FieldData<2, ::apache::thrift::type_class::binary, ::std::string*>> GraphService_authenticate_pargs; +typedef apache::thrift::ThriftPresult> GraphService_authenticate_presult; +typedef apache::thrift::ThriftPresult> GraphService_signout_pargs; +typedef apache::thrift::ThriftPresult, apache::thrift::FieldData<2, ::apache::thrift::type_class::binary, ::std::string*>> GraphService_execute_pargs; +typedef apache::thrift::ThriftPresult> GraphService_execute_presult; +typedef apache::thrift::ThriftPresult, apache::thrift::FieldData<2, ::apache::thrift::type_class::binary, ::std::string*>> GraphService_executeJson_pargs; +typedef apache::thrift::ThriftPresult> GraphService_executeJson_presult; +typedef apache::thrift::ThriftPresult> GraphService_verifyClientVersion_pargs; +typedef apache::thrift::ThriftPresult> GraphService_verifyClientVersion_presult; + +template +void GraphServiceAsyncClient::authenticateT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::std::string& p_username, const ::std::string& p_password) { + + std::shared_ptr header(ctx, &ctx->header); + GraphService_authenticate_pargs args; + args.get<0>().value = const_cast<::std::string*>(&p_username); + args.get<1>().value = const_cast<::std::string*>(&p_password); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "authenticate"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void GraphServiceAsyncClient::signoutT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, int64_t p_sessionId) { + + std::shared_ptr header(ctx, &ctx->header); + GraphService_signout_pargs args; + args.get<0>().value = &p_sessionId; + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "signout"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void GraphServiceAsyncClient::executeT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, int64_t p_sessionId, const ::std::string& p_stmt) { + + std::shared_ptr header(ctx, &ctx->header); + GraphService_execute_pargs args; + args.get<0>().value = &p_sessionId; + args.get<1>().value = const_cast<::std::string*>(&p_stmt); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "execute"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void GraphServiceAsyncClient::executeJsonT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, int64_t p_sessionId, const ::std::string& p_stmt) { + + std::shared_ptr header(ctx, &ctx->header); + GraphService_executeJson_pargs args; + args.get<0>().value = &p_sessionId; + args.get<1>().value = const_cast<::std::string*>(&p_stmt); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "executeJson"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void GraphServiceAsyncClient::verifyClientVersionT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::graph::cpp2::VerifyClientVersionReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + GraphService_verifyClientVersion_pargs args; + args.get<0>().value = const_cast< ::nebula::graph::cpp2::VerifyClientVersionReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "verifyClientVersion"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + + + +void GraphServiceAsyncClient::authenticate(std::unique_ptr callback, const ::std::string& p_username, const ::std::string& p_password) { + ::apache::thrift::RpcOptions rpcOptions; + authenticate(rpcOptions, std::move(callback), p_username, p_password); +} + +void GraphServiceAsyncClient::authenticate(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::std::string& p_username, const ::std::string& p_password) { + auto ctx = authenticateCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + authenticateImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_username, p_password); +} + +void GraphServiceAsyncClient::authenticateImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::std::string& p_username, const ::std::string& p_password) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + authenticateT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_username, p_password); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + authenticateT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_username, p_password); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> GraphServiceAsyncClient::authenticateCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "GraphService.authenticate"); +} + +void GraphServiceAsyncClient::sync_authenticate(nebula::AuthResponse& _return, const ::std::string& p_username, const ::std::string& p_password) { + ::apache::thrift::RpcOptions rpcOptions; + sync_authenticate(rpcOptions, _return, p_username, p_password); +} + +void GraphServiceAsyncClient::sync_authenticate(apache::thrift::RpcOptions& rpcOptions, nebula::AuthResponse& _return, const ::std::string& p_username, const ::std::string& p_password) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = authenticateCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + authenticateImpl(rpcOptions, ctx, std::move(wrappedCallback), p_username, p_password); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_authenticate(_return, returnState); + }); +} + + +folly::Future GraphServiceAsyncClient::future_authenticate(const ::std::string& p_username, const ::std::string& p_password) { + ::apache::thrift::RpcOptions rpcOptions; + return future_authenticate(rpcOptions, p_username, p_password); +} + +folly::SemiFuture GraphServiceAsyncClient::semifuture_authenticate(const ::std::string& p_username, const ::std::string& p_password) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_authenticate(rpcOptions, p_username, p_password); +} + +folly::Future GraphServiceAsyncClient::future_authenticate(apache::thrift::RpcOptions& rpcOptions, const ::std::string& p_username, const ::std::string& p_password) { + folly::Promise promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_authenticate, channel_); + authenticate(rpcOptions, std::move(callback), p_username, p_password); + return future; +} + +folly::SemiFuture GraphServiceAsyncClient::semifuture_authenticate(apache::thrift::RpcOptions& rpcOptions, const ::std::string& p_username, const ::std::string& p_password) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_authenticate, channel_); + auto callback = std::move(callbackAndFuture.first); + authenticate(rpcOptions, std::move(callback), p_username, p_password); + return std::move(callbackAndFuture.second); +} + +folly::Future>> GraphServiceAsyncClient::header_future_authenticate(apache::thrift::RpcOptions& rpcOptions, const ::std::string& p_username, const ::std::string& p_password) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_authenticate, channel_); + authenticate(rpcOptions, std::move(callback), p_username, p_password); + return future; +} + +folly::SemiFuture>> GraphServiceAsyncClient::header_semifuture_authenticate(apache::thrift::RpcOptions& rpcOptions, const ::std::string& p_username, const ::std::string& p_password) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_authenticate, channel_); + auto callback = std::move(callbackAndFuture.first); + authenticate(rpcOptions, std::move(callback), p_username, p_password); + return std::move(callbackAndFuture.second); +} + +void GraphServiceAsyncClient::authenticate(folly::Function callback, const ::std::string& p_username, const ::std::string& p_password) { + authenticate(std::make_unique(std::move(callback)), p_username, p_password); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper GraphServiceAsyncClient::recv_wrapped_authenticate(nebula::AuthResponse& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = GraphService_authenticate_presult; + constexpr auto const fname = "authenticate"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void GraphServiceAsyncClient::recv_authenticate(nebula::AuthResponse& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_authenticate(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void GraphServiceAsyncClient::recv_instance_authenticate(nebula::AuthResponse& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_authenticate(_return, state); +} + +folly::exception_wrapper GraphServiceAsyncClient::recv_instance_wrapped_authenticate(nebula::AuthResponse& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_authenticate(_return, state); +} + +void GraphServiceAsyncClient::signout(std::unique_ptr callback, int64_t p_sessionId) { + ::apache::thrift::RpcOptions rpcOptions; + signout(rpcOptions, std::move(callback), p_sessionId); +} + +void GraphServiceAsyncClient::signout(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, int64_t p_sessionId) { + auto ctx = signoutCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.oneWay = true; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + signoutImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_sessionId); +} + +void GraphServiceAsyncClient::signoutImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, int64_t p_sessionId) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + signoutT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_sessionId); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + signoutT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_sessionId); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> GraphServiceAsyncClient::signoutCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "GraphService.signout"); +} + +void GraphServiceAsyncClient::sync_signout(int64_t p_sessionId) { + ::apache::thrift::RpcOptions rpcOptions; + sync_signout(rpcOptions, p_sessionId); +} + +void GraphServiceAsyncClient::sync_signout(apache::thrift::RpcOptions& rpcOptions, int64_t p_sessionId) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = signoutCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + signoutImpl(rpcOptions, ctx, std::move(wrappedCallback), p_sessionId); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } +} + + +folly::Future GraphServiceAsyncClient::future_signout(int64_t p_sessionId) { + ::apache::thrift::RpcOptions rpcOptions; + return future_signout(rpcOptions, p_sessionId); +} + +folly::SemiFuture GraphServiceAsyncClient::semifuture_signout(int64_t p_sessionId) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_signout(rpcOptions, p_sessionId); +} + +folly::Future GraphServiceAsyncClient::future_signout(apache::thrift::RpcOptions& rpcOptions, int64_t p_sessionId) { + folly::Promise promise; + auto future = promise.getFuture(); + auto callback = std::make_unique(std::move(promise), channel_); + signout(rpcOptions, std::move(callback), p_sessionId); + return future; +} + +folly::SemiFuture GraphServiceAsyncClient::semifuture_signout(apache::thrift::RpcOptions& rpcOptions, int64_t p_sessionId) { + auto callbackAndFuture = makeOneWaySemiFutureCallback(channel_); + auto callback = std::move(callbackAndFuture.first); + signout(rpcOptions, std::move(callback), p_sessionId); + return std::move(callbackAndFuture.second); +} + + +void GraphServiceAsyncClient::signout(folly::Function callback, int64_t p_sessionId) { + signout(std::make_unique(std::move(callback)), p_sessionId); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +void GraphServiceAsyncClient::execute(std::unique_ptr callback, int64_t p_sessionId, const ::std::string& p_stmt) { + ::apache::thrift::RpcOptions rpcOptions; + execute(rpcOptions, std::move(callback), p_sessionId, p_stmt); +} + +void GraphServiceAsyncClient::execute(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, int64_t p_sessionId, const ::std::string& p_stmt) { + auto ctx = executeCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + executeImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_sessionId, p_stmt); +} + +void GraphServiceAsyncClient::executeImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, int64_t p_sessionId, const ::std::string& p_stmt) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + executeT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_sessionId, p_stmt); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + executeT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_sessionId, p_stmt); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> GraphServiceAsyncClient::executeCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "GraphService.execute"); +} + +void GraphServiceAsyncClient::sync_execute(nebula::ExecutionResponse& _return, int64_t p_sessionId, const ::std::string& p_stmt) { + ::apache::thrift::RpcOptions rpcOptions; + sync_execute(rpcOptions, _return, p_sessionId, p_stmt); +} + +void GraphServiceAsyncClient::sync_execute(apache::thrift::RpcOptions& rpcOptions, nebula::ExecutionResponse& _return, int64_t p_sessionId, const ::std::string& p_stmt) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = executeCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + executeImpl(rpcOptions, ctx, std::move(wrappedCallback), p_sessionId, p_stmt); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_execute(_return, returnState); + }); +} + + +folly::Future GraphServiceAsyncClient::future_execute(int64_t p_sessionId, const ::std::string& p_stmt) { + ::apache::thrift::RpcOptions rpcOptions; + return future_execute(rpcOptions, p_sessionId, p_stmt); +} + +folly::SemiFuture GraphServiceAsyncClient::semifuture_execute(int64_t p_sessionId, const ::std::string& p_stmt) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_execute(rpcOptions, p_sessionId, p_stmt); +} + +folly::Future GraphServiceAsyncClient::future_execute(apache::thrift::RpcOptions& rpcOptions, int64_t p_sessionId, const ::std::string& p_stmt) { + folly::Promise promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_execute, channel_); + execute(rpcOptions, std::move(callback), p_sessionId, p_stmt); + return future; +} + +folly::SemiFuture GraphServiceAsyncClient::semifuture_execute(apache::thrift::RpcOptions& rpcOptions, int64_t p_sessionId, const ::std::string& p_stmt) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_execute, channel_); + auto callback = std::move(callbackAndFuture.first); + execute(rpcOptions, std::move(callback), p_sessionId, p_stmt); + return std::move(callbackAndFuture.second); +} + +folly::Future>> GraphServiceAsyncClient::header_future_execute(apache::thrift::RpcOptions& rpcOptions, int64_t p_sessionId, const ::std::string& p_stmt) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_execute, channel_); + execute(rpcOptions, std::move(callback), p_sessionId, p_stmt); + return future; +} + +folly::SemiFuture>> GraphServiceAsyncClient::header_semifuture_execute(apache::thrift::RpcOptions& rpcOptions, int64_t p_sessionId, const ::std::string& p_stmt) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_execute, channel_); + auto callback = std::move(callbackAndFuture.first); + execute(rpcOptions, std::move(callback), p_sessionId, p_stmt); + return std::move(callbackAndFuture.second); +} + +void GraphServiceAsyncClient::execute(folly::Function callback, int64_t p_sessionId, const ::std::string& p_stmt) { + execute(std::make_unique(std::move(callback)), p_sessionId, p_stmt); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper GraphServiceAsyncClient::recv_wrapped_execute(nebula::ExecutionResponse& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = GraphService_execute_presult; + constexpr auto const fname = "execute"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void GraphServiceAsyncClient::recv_execute(nebula::ExecutionResponse& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_execute(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void GraphServiceAsyncClient::recv_instance_execute(nebula::ExecutionResponse& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_execute(_return, state); +} + +folly::exception_wrapper GraphServiceAsyncClient::recv_instance_wrapped_execute(nebula::ExecutionResponse& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_execute(_return, state); +} + +void GraphServiceAsyncClient::executeJson(std::unique_ptr callback, int64_t p_sessionId, const ::std::string& p_stmt) { + ::apache::thrift::RpcOptions rpcOptions; + executeJson(rpcOptions, std::move(callback), p_sessionId, p_stmt); +} + +void GraphServiceAsyncClient::executeJson(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, int64_t p_sessionId, const ::std::string& p_stmt) { + auto ctx = executeJsonCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + executeJsonImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_sessionId, p_stmt); +} + +void GraphServiceAsyncClient::executeJsonImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, int64_t p_sessionId, const ::std::string& p_stmt) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + executeJsonT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_sessionId, p_stmt); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + executeJsonT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_sessionId, p_stmt); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> GraphServiceAsyncClient::executeJsonCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "GraphService.executeJson"); +} + +void GraphServiceAsyncClient::sync_executeJson(::std::string& _return, int64_t p_sessionId, const ::std::string& p_stmt) { + ::apache::thrift::RpcOptions rpcOptions; + sync_executeJson(rpcOptions, _return, p_sessionId, p_stmt); +} + +void GraphServiceAsyncClient::sync_executeJson(apache::thrift::RpcOptions& rpcOptions, ::std::string& _return, int64_t p_sessionId, const ::std::string& p_stmt) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = executeJsonCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + executeJsonImpl(rpcOptions, ctx, std::move(wrappedCallback), p_sessionId, p_stmt); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_executeJson(_return, returnState); + }); +} + + +folly::Future<::std::string> GraphServiceAsyncClient::future_executeJson(int64_t p_sessionId, const ::std::string& p_stmt) { + ::apache::thrift::RpcOptions rpcOptions; + return future_executeJson(rpcOptions, p_sessionId, p_stmt); +} + +folly::SemiFuture<::std::string> GraphServiceAsyncClient::semifuture_executeJson(int64_t p_sessionId, const ::std::string& p_stmt) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_executeJson(rpcOptions, p_sessionId, p_stmt); +} + +folly::Future<::std::string> GraphServiceAsyncClient::future_executeJson(apache::thrift::RpcOptions& rpcOptions, int64_t p_sessionId, const ::std::string& p_stmt) { + folly::Promise<::std::string> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_executeJson, channel_); + executeJson(rpcOptions, std::move(callback), p_sessionId, p_stmt); + return future; +} + +folly::SemiFuture<::std::string> GraphServiceAsyncClient::semifuture_executeJson(apache::thrift::RpcOptions& rpcOptions, int64_t p_sessionId, const ::std::string& p_stmt) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_executeJson, channel_); + auto callback = std::move(callbackAndFuture.first); + executeJson(rpcOptions, std::move(callback), p_sessionId, p_stmt); + return std::move(callbackAndFuture.second); +} + +folly::Future>> GraphServiceAsyncClient::header_future_executeJson(apache::thrift::RpcOptions& rpcOptions, int64_t p_sessionId, const ::std::string& p_stmt) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_executeJson, channel_); + executeJson(rpcOptions, std::move(callback), p_sessionId, p_stmt); + return future; +} + +folly::SemiFuture>> GraphServiceAsyncClient::header_semifuture_executeJson(apache::thrift::RpcOptions& rpcOptions, int64_t p_sessionId, const ::std::string& p_stmt) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_executeJson, channel_); + auto callback = std::move(callbackAndFuture.first); + executeJson(rpcOptions, std::move(callback), p_sessionId, p_stmt); + return std::move(callbackAndFuture.second); +} + +void GraphServiceAsyncClient::executeJson(folly::Function callback, int64_t p_sessionId, const ::std::string& p_stmt) { + executeJson(std::make_unique(std::move(callback)), p_sessionId, p_stmt); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper GraphServiceAsyncClient::recv_wrapped_executeJson(::std::string& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = GraphService_executeJson_presult; + constexpr auto const fname = "executeJson"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void GraphServiceAsyncClient::recv_executeJson(::std::string& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_executeJson(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void GraphServiceAsyncClient::recv_instance_executeJson(::std::string& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_executeJson(_return, state); +} + +folly::exception_wrapper GraphServiceAsyncClient::recv_instance_wrapped_executeJson(::std::string& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_executeJson(_return, state); +} + +void GraphServiceAsyncClient::verifyClientVersion(std::unique_ptr callback, const ::nebula::graph::cpp2::VerifyClientVersionReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + verifyClientVersion(rpcOptions, std::move(callback), p_req); +} + +void GraphServiceAsyncClient::verifyClientVersion(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::graph::cpp2::VerifyClientVersionReq& p_req) { + auto ctx = verifyClientVersionCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + verifyClientVersionImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void GraphServiceAsyncClient::verifyClientVersionImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::graph::cpp2::VerifyClientVersionReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + verifyClientVersionT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + verifyClientVersionT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> GraphServiceAsyncClient::verifyClientVersionCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "GraphService.verifyClientVersion"); +} + +void GraphServiceAsyncClient::sync_verifyClientVersion( ::nebula::graph::cpp2::VerifyClientVersionResp& _return, const ::nebula::graph::cpp2::VerifyClientVersionReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_verifyClientVersion(rpcOptions, _return, p_req); +} + +void GraphServiceAsyncClient::sync_verifyClientVersion(apache::thrift::RpcOptions& rpcOptions, ::nebula::graph::cpp2::VerifyClientVersionResp& _return, const ::nebula::graph::cpp2::VerifyClientVersionReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = verifyClientVersionCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + verifyClientVersionImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_verifyClientVersion(_return, returnState); + }); +} + + +folly::Future< ::nebula::graph::cpp2::VerifyClientVersionResp> GraphServiceAsyncClient::future_verifyClientVersion(const ::nebula::graph::cpp2::VerifyClientVersionReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_verifyClientVersion(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::graph::cpp2::VerifyClientVersionResp> GraphServiceAsyncClient::semifuture_verifyClientVersion(const ::nebula::graph::cpp2::VerifyClientVersionReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_verifyClientVersion(rpcOptions, p_req); +} + +folly::Future< ::nebula::graph::cpp2::VerifyClientVersionResp> GraphServiceAsyncClient::future_verifyClientVersion(apache::thrift::RpcOptions& rpcOptions, const ::nebula::graph::cpp2::VerifyClientVersionReq& p_req) { + folly::Promise< ::nebula::graph::cpp2::VerifyClientVersionResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_verifyClientVersion, channel_); + verifyClientVersion(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::graph::cpp2::VerifyClientVersionResp> GraphServiceAsyncClient::semifuture_verifyClientVersion(apache::thrift::RpcOptions& rpcOptions, const ::nebula::graph::cpp2::VerifyClientVersionReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_verifyClientVersion, channel_); + auto callback = std::move(callbackAndFuture.first); + verifyClientVersion(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> GraphServiceAsyncClient::header_future_verifyClientVersion(apache::thrift::RpcOptions& rpcOptions, const ::nebula::graph::cpp2::VerifyClientVersionReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_verifyClientVersion, channel_); + verifyClientVersion(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> GraphServiceAsyncClient::header_semifuture_verifyClientVersion(apache::thrift::RpcOptions& rpcOptions, const ::nebula::graph::cpp2::VerifyClientVersionReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_verifyClientVersion, channel_); + auto callback = std::move(callbackAndFuture.first); + verifyClientVersion(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void GraphServiceAsyncClient::verifyClientVersion(folly::Function callback, const ::nebula::graph::cpp2::VerifyClientVersionReq& p_req) { + verifyClientVersion(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper GraphServiceAsyncClient::recv_wrapped_verifyClientVersion( ::nebula::graph::cpp2::VerifyClientVersionResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = GraphService_verifyClientVersion_presult; + constexpr auto const fname = "verifyClientVersion"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void GraphServiceAsyncClient::recv_verifyClientVersion( ::nebula::graph::cpp2::VerifyClientVersionResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_verifyClientVersion(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void GraphServiceAsyncClient::recv_instance_verifyClientVersion( ::nebula::graph::cpp2::VerifyClientVersionResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_verifyClientVersion(_return, state); +} + +folly::exception_wrapper GraphServiceAsyncClient::recv_instance_wrapped_verifyClientVersion( ::nebula::graph::cpp2::VerifyClientVersionResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_verifyClientVersion(_return, state); +} + + +}}} // nebula::graph::cpp2 diff --git a/src/interface/gen-cpp2/GraphServiceAsyncClient.h b/src/interface/gen-cpp2/GraphServiceAsyncClient.h new file mode 100644 index 00000000..229123c8 --- /dev/null +++ b/src/interface/gen-cpp2/GraphServiceAsyncClient.h @@ -0,0 +1,430 @@ +/** + * Autogenerated by Thrift for graph.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#pragma once + +#include + +#include "graph_types.h" +#include "common_types.h" +#include "common/graph/PairOps-inl.h" +#include "common/graph/ProfilingStatsOps-inl.h" +#include "common/graph/PlanNodeBranchInfoOps-inl.h" +#include "common/graph/PlanNodeDescriptionOps-inl.h" +#include "common/graph/PlanDescriptionOps-inl.h" +#include "common/graph/ExecutionResponseOps-inl.h" +#include "common/graph/AuthResponseOps-inl.h" + +namespace apache { namespace thrift { + class Cpp2RequestContext; + namespace detail { namespace ac { struct ClientRequestContext; }} + namespace transport { class THeader; } +}} + +namespace nebula { namespace graph { namespace cpp2 { + +class GraphServiceAsyncClient : public apache::thrift::GeneratedAsyncClient { + public: + using apache::thrift::GeneratedAsyncClient::GeneratedAsyncClient; + + char const* getServiceName() const noexcept override { + return "GraphService"; + } + + + virtual void authenticate(std::unique_ptr callback, const ::std::string& p_username, const ::std::string& p_password); + virtual void authenticate(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::std::string& p_username, const ::std::string& p_password); + protected: + void authenticateImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::std::string& p_username, const ::std::string& p_password); + public: + + virtual void sync_authenticate(nebula::AuthResponse& _return, const ::std::string& p_username, const ::std::string& p_password); + virtual void sync_authenticate(apache::thrift::RpcOptions& rpcOptions, nebula::AuthResponse& _return, const ::std::string& p_username, const ::std::string& p_password); + + virtual folly::Future future_authenticate(const ::std::string& p_username, const ::std::string& p_password); + virtual folly::SemiFuture semifuture_authenticate(const ::std::string& p_username, const ::std::string& p_password); + virtual folly::Future future_authenticate(apache::thrift::RpcOptions& rpcOptions, const ::std::string& p_username, const ::std::string& p_password); + virtual folly::SemiFuture semifuture_authenticate(apache::thrift::RpcOptions& rpcOptions, const ::std::string& p_username, const ::std::string& p_password); + virtual folly::Future>> header_future_authenticate(apache::thrift::RpcOptions& rpcOptions, const ::std::string& p_username, const ::std::string& p_password); + virtual folly::SemiFuture>> header_semifuture_authenticate(apache::thrift::RpcOptions& rpcOptions, const ::std::string& p_username, const ::std::string& p_password); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task co_authenticate(const ::std::string& p_username, const ::std::string& p_password) { + return co_authenticate(nullptr, p_username, p_password); + } + template + folly::coro::Task co_authenticate(apache::thrift::RpcOptions& rpcOptions, const ::std::string& p_username, const ::std::string& p_password) { + return co_authenticate(&rpcOptions, p_username, p_password); + } + private: + template + folly::coro::Task co_authenticate(apache::thrift::RpcOptions* rpcOptions, const ::std::string& p_username, const ::std::string& p_password) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = authenticateCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + authenticateImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_username, p_password); + } else { + authenticateImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_username, p_password); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + nebula::AuthResponse _return; + if (auto ew = recv_wrapped_authenticate(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void authenticate(folly::Function callback, const ::std::string& p_username, const ::std::string& p_password); + + + static folly::exception_wrapper recv_wrapped_authenticate(nebula::AuthResponse& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_authenticate(nebula::AuthResponse& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_authenticate(nebula::AuthResponse& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_authenticate(nebula::AuthResponse& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void authenticateT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::std::string& p_username, const ::std::string& p_password); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> authenticateCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void signout(std::unique_ptr callback, int64_t p_sessionId); + virtual void signout(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, int64_t p_sessionId); + protected: + void signoutImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, int64_t p_sessionId); + public: + + virtual void sync_signout(int64_t p_sessionId); + virtual void sync_signout(apache::thrift::RpcOptions& rpcOptions, int64_t p_sessionId); + + virtual folly::Future future_signout(int64_t p_sessionId); + virtual folly::SemiFuture semifuture_signout(int64_t p_sessionId); + virtual folly::Future future_signout(apache::thrift::RpcOptions& rpcOptions, int64_t p_sessionId); + virtual folly::SemiFuture semifuture_signout(apache::thrift::RpcOptions& rpcOptions, int64_t p_sessionId); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task co_signout(int64_t p_sessionId) { + return co_signout(nullptr, p_sessionId); + } + template + folly::coro::Task co_signout(apache::thrift::RpcOptions& rpcOptions, int64_t p_sessionId) { + return co_signout(&rpcOptions, p_sessionId); + } + private: + template + folly::coro::Task co_signout(apache::thrift::RpcOptions* rpcOptions, int64_t p_sessionId) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto ctx = signoutCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + signoutImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_sessionId); + } else { + signoutImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_sessionId); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void signout(folly::Function callback, int64_t p_sessionId); + + + private: + template + void signoutT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, int64_t p_sessionId); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> signoutCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void execute(std::unique_ptr callback, int64_t p_sessionId, const ::std::string& p_stmt); + virtual void execute(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, int64_t p_sessionId, const ::std::string& p_stmt); + protected: + void executeImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, int64_t p_sessionId, const ::std::string& p_stmt); + public: + + virtual void sync_execute(nebula::ExecutionResponse& _return, int64_t p_sessionId, const ::std::string& p_stmt); + virtual void sync_execute(apache::thrift::RpcOptions& rpcOptions, nebula::ExecutionResponse& _return, int64_t p_sessionId, const ::std::string& p_stmt); + + virtual folly::Future future_execute(int64_t p_sessionId, const ::std::string& p_stmt); + virtual folly::SemiFuture semifuture_execute(int64_t p_sessionId, const ::std::string& p_stmt); + virtual folly::Future future_execute(apache::thrift::RpcOptions& rpcOptions, int64_t p_sessionId, const ::std::string& p_stmt); + virtual folly::SemiFuture semifuture_execute(apache::thrift::RpcOptions& rpcOptions, int64_t p_sessionId, const ::std::string& p_stmt); + virtual folly::Future>> header_future_execute(apache::thrift::RpcOptions& rpcOptions, int64_t p_sessionId, const ::std::string& p_stmt); + virtual folly::SemiFuture>> header_semifuture_execute(apache::thrift::RpcOptions& rpcOptions, int64_t p_sessionId, const ::std::string& p_stmt); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task co_execute(int64_t p_sessionId, const ::std::string& p_stmt) { + return co_execute(nullptr, p_sessionId, p_stmt); + } + template + folly::coro::Task co_execute(apache::thrift::RpcOptions& rpcOptions, int64_t p_sessionId, const ::std::string& p_stmt) { + return co_execute(&rpcOptions, p_sessionId, p_stmt); + } + private: + template + folly::coro::Task co_execute(apache::thrift::RpcOptions* rpcOptions, int64_t p_sessionId, const ::std::string& p_stmt) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = executeCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + executeImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_sessionId, p_stmt); + } else { + executeImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_sessionId, p_stmt); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + nebula::ExecutionResponse _return; + if (auto ew = recv_wrapped_execute(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void execute(folly::Function callback, int64_t p_sessionId, const ::std::string& p_stmt); + + + static folly::exception_wrapper recv_wrapped_execute(nebula::ExecutionResponse& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_execute(nebula::ExecutionResponse& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_execute(nebula::ExecutionResponse& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_execute(nebula::ExecutionResponse& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void executeT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, int64_t p_sessionId, const ::std::string& p_stmt); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> executeCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void executeJson(std::unique_ptr callback, int64_t p_sessionId, const ::std::string& p_stmt); + virtual void executeJson(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, int64_t p_sessionId, const ::std::string& p_stmt); + protected: + void executeJsonImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, int64_t p_sessionId, const ::std::string& p_stmt); + public: + + virtual void sync_executeJson(::std::string& _return, int64_t p_sessionId, const ::std::string& p_stmt); + virtual void sync_executeJson(apache::thrift::RpcOptions& rpcOptions, ::std::string& _return, int64_t p_sessionId, const ::std::string& p_stmt); + + virtual folly::Future<::std::string> future_executeJson(int64_t p_sessionId, const ::std::string& p_stmt); + virtual folly::SemiFuture<::std::string> semifuture_executeJson(int64_t p_sessionId, const ::std::string& p_stmt); + virtual folly::Future<::std::string> future_executeJson(apache::thrift::RpcOptions& rpcOptions, int64_t p_sessionId, const ::std::string& p_stmt); + virtual folly::SemiFuture<::std::string> semifuture_executeJson(apache::thrift::RpcOptions& rpcOptions, int64_t p_sessionId, const ::std::string& p_stmt); + virtual folly::Future>> header_future_executeJson(apache::thrift::RpcOptions& rpcOptions, int64_t p_sessionId, const ::std::string& p_stmt); + virtual folly::SemiFuture>> header_semifuture_executeJson(apache::thrift::RpcOptions& rpcOptions, int64_t p_sessionId, const ::std::string& p_stmt); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task<::std::string> co_executeJson(int64_t p_sessionId, const ::std::string& p_stmt) { + return co_executeJson(nullptr, p_sessionId, p_stmt); + } + template + folly::coro::Task<::std::string> co_executeJson(apache::thrift::RpcOptions& rpcOptions, int64_t p_sessionId, const ::std::string& p_stmt) { + return co_executeJson(&rpcOptions, p_sessionId, p_stmt); + } + private: + template + folly::coro::Task<::std::string> co_executeJson(apache::thrift::RpcOptions* rpcOptions, int64_t p_sessionId, const ::std::string& p_stmt) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = executeJsonCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + executeJsonImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_sessionId, p_stmt); + } else { + executeJsonImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_sessionId, p_stmt); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::std::string _return; + if (auto ew = recv_wrapped_executeJson(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void executeJson(folly::Function callback, int64_t p_sessionId, const ::std::string& p_stmt); + + + static folly::exception_wrapper recv_wrapped_executeJson(::std::string& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_executeJson(::std::string& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_executeJson(::std::string& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_executeJson(::std::string& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void executeJsonT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, int64_t p_sessionId, const ::std::string& p_stmt); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> executeJsonCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void verifyClientVersion(std::unique_ptr callback, const ::nebula::graph::cpp2::VerifyClientVersionReq& p_req); + virtual void verifyClientVersion(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::graph::cpp2::VerifyClientVersionReq& p_req); + protected: + void verifyClientVersionImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::graph::cpp2::VerifyClientVersionReq& p_req); + public: + + virtual void sync_verifyClientVersion( ::nebula::graph::cpp2::VerifyClientVersionResp& _return, const ::nebula::graph::cpp2::VerifyClientVersionReq& p_req); + virtual void sync_verifyClientVersion(apache::thrift::RpcOptions& rpcOptions, ::nebula::graph::cpp2::VerifyClientVersionResp& _return, const ::nebula::graph::cpp2::VerifyClientVersionReq& p_req); + + virtual folly::Future< ::nebula::graph::cpp2::VerifyClientVersionResp> future_verifyClientVersion(const ::nebula::graph::cpp2::VerifyClientVersionReq& p_req); + virtual folly::SemiFuture< ::nebula::graph::cpp2::VerifyClientVersionResp> semifuture_verifyClientVersion(const ::nebula::graph::cpp2::VerifyClientVersionReq& p_req); + virtual folly::Future< ::nebula::graph::cpp2::VerifyClientVersionResp> future_verifyClientVersion(apache::thrift::RpcOptions& rpcOptions, const ::nebula::graph::cpp2::VerifyClientVersionReq& p_req); + virtual folly::SemiFuture< ::nebula::graph::cpp2::VerifyClientVersionResp> semifuture_verifyClientVersion(apache::thrift::RpcOptions& rpcOptions, const ::nebula::graph::cpp2::VerifyClientVersionReq& p_req); + virtual folly::Future>> header_future_verifyClientVersion(apache::thrift::RpcOptions& rpcOptions, const ::nebula::graph::cpp2::VerifyClientVersionReq& p_req); + virtual folly::SemiFuture>> header_semifuture_verifyClientVersion(apache::thrift::RpcOptions& rpcOptions, const ::nebula::graph::cpp2::VerifyClientVersionReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::graph::cpp2::VerifyClientVersionResp> co_verifyClientVersion(const ::nebula::graph::cpp2::VerifyClientVersionReq& p_req) { + return co_verifyClientVersion(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::graph::cpp2::VerifyClientVersionResp> co_verifyClientVersion(apache::thrift::RpcOptions& rpcOptions, const ::nebula::graph::cpp2::VerifyClientVersionReq& p_req) { + return co_verifyClientVersion(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::graph::cpp2::VerifyClientVersionResp> co_verifyClientVersion(apache::thrift::RpcOptions* rpcOptions, const ::nebula::graph::cpp2::VerifyClientVersionReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = verifyClientVersionCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + verifyClientVersionImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + verifyClientVersionImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::graph::cpp2::VerifyClientVersionResp _return; + if (auto ew = recv_wrapped_verifyClientVersion(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void verifyClientVersion(folly::Function callback, const ::nebula::graph::cpp2::VerifyClientVersionReq& p_req); + + + static folly::exception_wrapper recv_wrapped_verifyClientVersion( ::nebula::graph::cpp2::VerifyClientVersionResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_verifyClientVersion( ::nebula::graph::cpp2::VerifyClientVersionResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_verifyClientVersion( ::nebula::graph::cpp2::VerifyClientVersionResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_verifyClientVersion( ::nebula::graph::cpp2::VerifyClientVersionResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void verifyClientVersionT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::graph::cpp2::VerifyClientVersionReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> verifyClientVersionCtx(apache::thrift::RpcOptions* rpcOptions); + public: +}; + +}}} // nebula::graph::cpp2 diff --git a/src/interface/gen-cpp2/GraphService_custom_protocol.h b/src/interface/gen-cpp2/GraphService_custom_protocol.h new file mode 100644 index 00000000..09c374b8 --- /dev/null +++ b/src/interface/gen-cpp2/GraphService_custom_protocol.h @@ -0,0 +1,18 @@ +/** + * Autogenerated by Thrift for graph.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#pragma once + +/** + * This header file includes the tcc files of the corresponding header file + * and the header files of its dependent types. Include this header file + * only when you need to use custom protocols (e.g. DebugProtocol, + * VirtualProtocol) to read/write thrift structs. + */ + +#include "GraphService.tcc" +#include "graph_types_custom_protocol.h" +#include "common_types_custom_protocol.h" diff --git a/src/interface/gen-cpp2/GraphService_processmap_binary.cpp b/src/interface/gen-cpp2/GraphService_processmap_binary.cpp new file mode 100644 index 00000000..c722cf39 --- /dev/null +++ b/src/interface/gen-cpp2/GraphService_processmap_binary.cpp @@ -0,0 +1,12 @@ +/** + * Autogenerated by Thrift for graph.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ + +#include "GraphService.h" +#include "GraphService.tcc" + +namespace nebula { namespace graph { namespace cpp2 { +}}} // nebula::graph::cpp2 diff --git a/src/interface/gen-cpp2/GraphService_processmap_compact.cpp b/src/interface/gen-cpp2/GraphService_processmap_compact.cpp new file mode 100644 index 00000000..c722cf39 --- /dev/null +++ b/src/interface/gen-cpp2/GraphService_processmap_compact.cpp @@ -0,0 +1,12 @@ +/** + * Autogenerated by Thrift for graph.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ + +#include "GraphService.h" +#include "GraphService.tcc" + +namespace nebula { namespace graph { namespace cpp2 { +}}} // nebula::graph::cpp2 diff --git a/src/interface/gen-cpp2/GraphStorageService.cpp b/src/interface/gen-cpp2/GraphStorageService.cpp new file mode 100644 index 00000000..5a0c6071 --- /dev/null +++ b/src/interface/gen-cpp2/GraphStorageService.cpp @@ -0,0 +1,450 @@ +/** + * Autogenerated by Thrift for storage.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#include "GraphStorageService.h" +#include "GraphStorageService.tcc" +#include "storage_metadata.h" +#include + +namespace nebula { namespace storage { namespace cpp2 { +std::unique_ptr GraphStorageServiceSvIf::getProcessor() { + return std::make_unique(this); +} + + +void GraphStorageServiceSvIf::getNeighbors( ::nebula::storage::cpp2::GetNeighborsResponse& /*_return*/, const ::nebula::storage::cpp2::GetNeighborsRequest& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("getNeighbors"); +} + +folly::SemiFuture< ::nebula::storage::cpp2::GetNeighborsResponse> GraphStorageServiceSvIf::semifuture_getNeighbors(const ::nebula::storage::cpp2::GetNeighborsRequest& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::storage::cpp2::GetNeighborsResponse& _return) { getNeighbors(_return, p_req); }); +} + +folly::Future< ::nebula::storage::cpp2::GetNeighborsResponse> GraphStorageServiceSvIf::future_getNeighbors(const ::nebula::storage::cpp2::GetNeighborsRequest& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_getNeighbors(p_req), std::move(ka)); +} + +void GraphStorageServiceSvIf::async_tm_getNeighbors(std::unique_ptr> callback, const ::nebula::storage::cpp2::GetNeighborsRequest& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_getNeighbors(p_req); + }); +} + +void GraphStorageServiceSvIf::getProps( ::nebula::storage::cpp2::GetPropResponse& /*_return*/, const ::nebula::storage::cpp2::GetPropRequest& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("getProps"); +} + +folly::SemiFuture< ::nebula::storage::cpp2::GetPropResponse> GraphStorageServiceSvIf::semifuture_getProps(const ::nebula::storage::cpp2::GetPropRequest& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::storage::cpp2::GetPropResponse& _return) { getProps(_return, p_req); }); +} + +folly::Future< ::nebula::storage::cpp2::GetPropResponse> GraphStorageServiceSvIf::future_getProps(const ::nebula::storage::cpp2::GetPropRequest& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_getProps(p_req), std::move(ka)); +} + +void GraphStorageServiceSvIf::async_tm_getProps(std::unique_ptr> callback, const ::nebula::storage::cpp2::GetPropRequest& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_getProps(p_req); + }); +} + +void GraphStorageServiceSvIf::addVertices( ::nebula::storage::cpp2::ExecResponse& /*_return*/, const ::nebula::storage::cpp2::AddVerticesRequest& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("addVertices"); +} + +folly::SemiFuture< ::nebula::storage::cpp2::ExecResponse> GraphStorageServiceSvIf::semifuture_addVertices(const ::nebula::storage::cpp2::AddVerticesRequest& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::storage::cpp2::ExecResponse& _return) { addVertices(_return, p_req); }); +} + +folly::Future< ::nebula::storage::cpp2::ExecResponse> GraphStorageServiceSvIf::future_addVertices(const ::nebula::storage::cpp2::AddVerticesRequest& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_addVertices(p_req), std::move(ka)); +} + +void GraphStorageServiceSvIf::async_tm_addVertices(std::unique_ptr> callback, const ::nebula::storage::cpp2::AddVerticesRequest& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_addVertices(p_req); + }); +} + +void GraphStorageServiceSvIf::addEdges( ::nebula::storage::cpp2::ExecResponse& /*_return*/, const ::nebula::storage::cpp2::AddEdgesRequest& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("addEdges"); +} + +folly::SemiFuture< ::nebula::storage::cpp2::ExecResponse> GraphStorageServiceSvIf::semifuture_addEdges(const ::nebula::storage::cpp2::AddEdgesRequest& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::storage::cpp2::ExecResponse& _return) { addEdges(_return, p_req); }); +} + +folly::Future< ::nebula::storage::cpp2::ExecResponse> GraphStorageServiceSvIf::future_addEdges(const ::nebula::storage::cpp2::AddEdgesRequest& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_addEdges(p_req), std::move(ka)); +} + +void GraphStorageServiceSvIf::async_tm_addEdges(std::unique_ptr> callback, const ::nebula::storage::cpp2::AddEdgesRequest& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_addEdges(p_req); + }); +} + +void GraphStorageServiceSvIf::deleteEdges( ::nebula::storage::cpp2::ExecResponse& /*_return*/, const ::nebula::storage::cpp2::DeleteEdgesRequest& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("deleteEdges"); +} + +folly::SemiFuture< ::nebula::storage::cpp2::ExecResponse> GraphStorageServiceSvIf::semifuture_deleteEdges(const ::nebula::storage::cpp2::DeleteEdgesRequest& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::storage::cpp2::ExecResponse& _return) { deleteEdges(_return, p_req); }); +} + +folly::Future< ::nebula::storage::cpp2::ExecResponse> GraphStorageServiceSvIf::future_deleteEdges(const ::nebula::storage::cpp2::DeleteEdgesRequest& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_deleteEdges(p_req), std::move(ka)); +} + +void GraphStorageServiceSvIf::async_tm_deleteEdges(std::unique_ptr> callback, const ::nebula::storage::cpp2::DeleteEdgesRequest& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_deleteEdges(p_req); + }); +} + +void GraphStorageServiceSvIf::deleteVertices( ::nebula::storage::cpp2::ExecResponse& /*_return*/, const ::nebula::storage::cpp2::DeleteVerticesRequest& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("deleteVertices"); +} + +folly::SemiFuture< ::nebula::storage::cpp2::ExecResponse> GraphStorageServiceSvIf::semifuture_deleteVertices(const ::nebula::storage::cpp2::DeleteVerticesRequest& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::storage::cpp2::ExecResponse& _return) { deleteVertices(_return, p_req); }); +} + +folly::Future< ::nebula::storage::cpp2::ExecResponse> GraphStorageServiceSvIf::future_deleteVertices(const ::nebula::storage::cpp2::DeleteVerticesRequest& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_deleteVertices(p_req), std::move(ka)); +} + +void GraphStorageServiceSvIf::async_tm_deleteVertices(std::unique_ptr> callback, const ::nebula::storage::cpp2::DeleteVerticesRequest& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_deleteVertices(p_req); + }); +} + +void GraphStorageServiceSvIf::deleteTags( ::nebula::storage::cpp2::ExecResponse& /*_return*/, const ::nebula::storage::cpp2::DeleteTagsRequest& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("deleteTags"); +} + +folly::SemiFuture< ::nebula::storage::cpp2::ExecResponse> GraphStorageServiceSvIf::semifuture_deleteTags(const ::nebula::storage::cpp2::DeleteTagsRequest& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::storage::cpp2::ExecResponse& _return) { deleteTags(_return, p_req); }); +} + +folly::Future< ::nebula::storage::cpp2::ExecResponse> GraphStorageServiceSvIf::future_deleteTags(const ::nebula::storage::cpp2::DeleteTagsRequest& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_deleteTags(p_req), std::move(ka)); +} + +void GraphStorageServiceSvIf::async_tm_deleteTags(std::unique_ptr> callback, const ::nebula::storage::cpp2::DeleteTagsRequest& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_deleteTags(p_req); + }); +} + +void GraphStorageServiceSvIf::updateVertex( ::nebula::storage::cpp2::UpdateResponse& /*_return*/, const ::nebula::storage::cpp2::UpdateVertexRequest& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("updateVertex"); +} + +folly::SemiFuture< ::nebula::storage::cpp2::UpdateResponse> GraphStorageServiceSvIf::semifuture_updateVertex(const ::nebula::storage::cpp2::UpdateVertexRequest& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::storage::cpp2::UpdateResponse& _return) { updateVertex(_return, p_req); }); +} + +folly::Future< ::nebula::storage::cpp2::UpdateResponse> GraphStorageServiceSvIf::future_updateVertex(const ::nebula::storage::cpp2::UpdateVertexRequest& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_updateVertex(p_req), std::move(ka)); +} + +void GraphStorageServiceSvIf::async_tm_updateVertex(std::unique_ptr> callback, const ::nebula::storage::cpp2::UpdateVertexRequest& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_updateVertex(p_req); + }); +} + +void GraphStorageServiceSvIf::updateEdge( ::nebula::storage::cpp2::UpdateResponse& /*_return*/, const ::nebula::storage::cpp2::UpdateEdgeRequest& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("updateEdge"); +} + +folly::SemiFuture< ::nebula::storage::cpp2::UpdateResponse> GraphStorageServiceSvIf::semifuture_updateEdge(const ::nebula::storage::cpp2::UpdateEdgeRequest& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::storage::cpp2::UpdateResponse& _return) { updateEdge(_return, p_req); }); +} + +folly::Future< ::nebula::storage::cpp2::UpdateResponse> GraphStorageServiceSvIf::future_updateEdge(const ::nebula::storage::cpp2::UpdateEdgeRequest& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_updateEdge(p_req), std::move(ka)); +} + +void GraphStorageServiceSvIf::async_tm_updateEdge(std::unique_ptr> callback, const ::nebula::storage::cpp2::UpdateEdgeRequest& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_updateEdge(p_req); + }); +} + +void GraphStorageServiceSvIf::scanVertex( ::nebula::storage::cpp2::ScanVertexResponse& /*_return*/, const ::nebula::storage::cpp2::ScanVertexRequest& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("scanVertex"); +} + +folly::SemiFuture< ::nebula::storage::cpp2::ScanVertexResponse> GraphStorageServiceSvIf::semifuture_scanVertex(const ::nebula::storage::cpp2::ScanVertexRequest& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::storage::cpp2::ScanVertexResponse& _return) { scanVertex(_return, p_req); }); +} + +folly::Future< ::nebula::storage::cpp2::ScanVertexResponse> GraphStorageServiceSvIf::future_scanVertex(const ::nebula::storage::cpp2::ScanVertexRequest& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_scanVertex(p_req), std::move(ka)); +} + +void GraphStorageServiceSvIf::async_tm_scanVertex(std::unique_ptr> callback, const ::nebula::storage::cpp2::ScanVertexRequest& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_scanVertex(p_req); + }); +} + +void GraphStorageServiceSvIf::scanEdge( ::nebula::storage::cpp2::ScanEdgeResponse& /*_return*/, const ::nebula::storage::cpp2::ScanEdgeRequest& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("scanEdge"); +} + +folly::SemiFuture< ::nebula::storage::cpp2::ScanEdgeResponse> GraphStorageServiceSvIf::semifuture_scanEdge(const ::nebula::storage::cpp2::ScanEdgeRequest& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::storage::cpp2::ScanEdgeResponse& _return) { scanEdge(_return, p_req); }); +} + +folly::Future< ::nebula::storage::cpp2::ScanEdgeResponse> GraphStorageServiceSvIf::future_scanEdge(const ::nebula::storage::cpp2::ScanEdgeRequest& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_scanEdge(p_req), std::move(ka)); +} + +void GraphStorageServiceSvIf::async_tm_scanEdge(std::unique_ptr> callback, const ::nebula::storage::cpp2::ScanEdgeRequest& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_scanEdge(p_req); + }); +} + +void GraphStorageServiceSvIf::getUUID( ::nebula::storage::cpp2::GetUUIDResp& /*_return*/, const ::nebula::storage::cpp2::GetUUIDReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("getUUID"); +} + +folly::SemiFuture< ::nebula::storage::cpp2::GetUUIDResp> GraphStorageServiceSvIf::semifuture_getUUID(const ::nebula::storage::cpp2::GetUUIDReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::storage::cpp2::GetUUIDResp& _return) { getUUID(_return, p_req); }); +} + +folly::Future< ::nebula::storage::cpp2::GetUUIDResp> GraphStorageServiceSvIf::future_getUUID(const ::nebula::storage::cpp2::GetUUIDReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_getUUID(p_req), std::move(ka)); +} + +void GraphStorageServiceSvIf::async_tm_getUUID(std::unique_ptr> callback, const ::nebula::storage::cpp2::GetUUIDReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_getUUID(p_req); + }); +} + +void GraphStorageServiceSvIf::lookupIndex( ::nebula::storage::cpp2::LookupIndexResp& /*_return*/, const ::nebula::storage::cpp2::LookupIndexRequest& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("lookupIndex"); +} + +folly::SemiFuture< ::nebula::storage::cpp2::LookupIndexResp> GraphStorageServiceSvIf::semifuture_lookupIndex(const ::nebula::storage::cpp2::LookupIndexRequest& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::storage::cpp2::LookupIndexResp& _return) { lookupIndex(_return, p_req); }); +} + +folly::Future< ::nebula::storage::cpp2::LookupIndexResp> GraphStorageServiceSvIf::future_lookupIndex(const ::nebula::storage::cpp2::LookupIndexRequest& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_lookupIndex(p_req), std::move(ka)); +} + +void GraphStorageServiceSvIf::async_tm_lookupIndex(std::unique_ptr> callback, const ::nebula::storage::cpp2::LookupIndexRequest& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_lookupIndex(p_req); + }); +} + +void GraphStorageServiceSvIf::lookupAndTraverse( ::nebula::storage::cpp2::GetNeighborsResponse& /*_return*/, const ::nebula::storage::cpp2::LookupAndTraverseRequest& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("lookupAndTraverse"); +} + +folly::SemiFuture< ::nebula::storage::cpp2::GetNeighborsResponse> GraphStorageServiceSvIf::semifuture_lookupAndTraverse(const ::nebula::storage::cpp2::LookupAndTraverseRequest& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::storage::cpp2::GetNeighborsResponse& _return) { lookupAndTraverse(_return, p_req); }); +} + +folly::Future< ::nebula::storage::cpp2::GetNeighborsResponse> GraphStorageServiceSvIf::future_lookupAndTraverse(const ::nebula::storage::cpp2::LookupAndTraverseRequest& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_lookupAndTraverse(p_req), std::move(ka)); +} + +void GraphStorageServiceSvIf::async_tm_lookupAndTraverse(std::unique_ptr> callback, const ::nebula::storage::cpp2::LookupAndTraverseRequest& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_lookupAndTraverse(p_req); + }); +} + +void GraphStorageServiceSvIf::chainUpdateEdge( ::nebula::storage::cpp2::UpdateResponse& /*_return*/, const ::nebula::storage::cpp2::UpdateEdgeRequest& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("chainUpdateEdge"); +} + +folly::SemiFuture< ::nebula::storage::cpp2::UpdateResponse> GraphStorageServiceSvIf::semifuture_chainUpdateEdge(const ::nebula::storage::cpp2::UpdateEdgeRequest& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::storage::cpp2::UpdateResponse& _return) { chainUpdateEdge(_return, p_req); }); +} + +folly::Future< ::nebula::storage::cpp2::UpdateResponse> GraphStorageServiceSvIf::future_chainUpdateEdge(const ::nebula::storage::cpp2::UpdateEdgeRequest& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_chainUpdateEdge(p_req), std::move(ka)); +} + +void GraphStorageServiceSvIf::async_tm_chainUpdateEdge(std::unique_ptr> callback, const ::nebula::storage::cpp2::UpdateEdgeRequest& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_chainUpdateEdge(p_req); + }); +} + +void GraphStorageServiceSvIf::chainAddEdges( ::nebula::storage::cpp2::ExecResponse& /*_return*/, const ::nebula::storage::cpp2::AddEdgesRequest& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("chainAddEdges"); +} + +folly::SemiFuture< ::nebula::storage::cpp2::ExecResponse> GraphStorageServiceSvIf::semifuture_chainAddEdges(const ::nebula::storage::cpp2::AddEdgesRequest& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::storage::cpp2::ExecResponse& _return) { chainAddEdges(_return, p_req); }); +} + +folly::Future< ::nebula::storage::cpp2::ExecResponse> GraphStorageServiceSvIf::future_chainAddEdges(const ::nebula::storage::cpp2::AddEdgesRequest& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_chainAddEdges(p_req), std::move(ka)); +} + +void GraphStorageServiceSvIf::async_tm_chainAddEdges(std::unique_ptr> callback, const ::nebula::storage::cpp2::AddEdgesRequest& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_chainAddEdges(p_req); + }); +} + +void GraphStorageServiceSvNull::getNeighbors( ::nebula::storage::cpp2::GetNeighborsResponse& /*_return*/, const ::nebula::storage::cpp2::GetNeighborsRequest& /*req*/) {} + +void GraphStorageServiceSvNull::getProps( ::nebula::storage::cpp2::GetPropResponse& /*_return*/, const ::nebula::storage::cpp2::GetPropRequest& /*req*/) {} + +void GraphStorageServiceSvNull::addVertices( ::nebula::storage::cpp2::ExecResponse& /*_return*/, const ::nebula::storage::cpp2::AddVerticesRequest& /*req*/) {} + +void GraphStorageServiceSvNull::addEdges( ::nebula::storage::cpp2::ExecResponse& /*_return*/, const ::nebula::storage::cpp2::AddEdgesRequest& /*req*/) {} + +void GraphStorageServiceSvNull::deleteEdges( ::nebula::storage::cpp2::ExecResponse& /*_return*/, const ::nebula::storage::cpp2::DeleteEdgesRequest& /*req*/) {} + +void GraphStorageServiceSvNull::deleteVertices( ::nebula::storage::cpp2::ExecResponse& /*_return*/, const ::nebula::storage::cpp2::DeleteVerticesRequest& /*req*/) {} + +void GraphStorageServiceSvNull::deleteTags( ::nebula::storage::cpp2::ExecResponse& /*_return*/, const ::nebula::storage::cpp2::DeleteTagsRequest& /*req*/) {} + +void GraphStorageServiceSvNull::updateVertex( ::nebula::storage::cpp2::UpdateResponse& /*_return*/, const ::nebula::storage::cpp2::UpdateVertexRequest& /*req*/) {} + +void GraphStorageServiceSvNull::updateEdge( ::nebula::storage::cpp2::UpdateResponse& /*_return*/, const ::nebula::storage::cpp2::UpdateEdgeRequest& /*req*/) {} + +void GraphStorageServiceSvNull::scanVertex( ::nebula::storage::cpp2::ScanVertexResponse& /*_return*/, const ::nebula::storage::cpp2::ScanVertexRequest& /*req*/) {} + +void GraphStorageServiceSvNull::scanEdge( ::nebula::storage::cpp2::ScanEdgeResponse& /*_return*/, const ::nebula::storage::cpp2::ScanEdgeRequest& /*req*/) {} + +void GraphStorageServiceSvNull::getUUID( ::nebula::storage::cpp2::GetUUIDResp& /*_return*/, const ::nebula::storage::cpp2::GetUUIDReq& /*req*/) {} + +void GraphStorageServiceSvNull::lookupIndex( ::nebula::storage::cpp2::LookupIndexResp& /*_return*/, const ::nebula::storage::cpp2::LookupIndexRequest& /*req*/) {} + +void GraphStorageServiceSvNull::lookupAndTraverse( ::nebula::storage::cpp2::GetNeighborsResponse& /*_return*/, const ::nebula::storage::cpp2::LookupAndTraverseRequest& /*req*/) {} + +void GraphStorageServiceSvNull::chainUpdateEdge( ::nebula::storage::cpp2::UpdateResponse& /*_return*/, const ::nebula::storage::cpp2::UpdateEdgeRequest& /*req*/) {} + +void GraphStorageServiceSvNull::chainAddEdges( ::nebula::storage::cpp2::ExecResponse& /*_return*/, const ::nebula::storage::cpp2::AddEdgesRequest& /*req*/) {} + + + +const char* GraphStorageServiceAsyncProcessor::getServiceName() { + return "GraphStorageService"; +} + +void GraphStorageServiceAsyncProcessor::getServiceMetadata(apache::thrift::metadata::ThriftServiceMetadataResponse& response) { + ::apache::thrift::detail::md::ServiceMetadata::gen(*response.metadata_ref(), *response.context_ref()); +} + +void GraphStorageServiceAsyncProcessor::processSerializedRequest(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::protocol::PROTOCOL_TYPES protType, apache::thrift::Cpp2RequestContext* context, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + apache::thrift::detail::ap::process(this, std::move(req), std::move(serializedRequest), protType, context, eb, tm); +} + +std::shared_ptr GraphStorageServiceAsyncProcessor::getBaseContextForRequest() { + return iface_->getBaseContextForRequest(); +} + +const GraphStorageServiceAsyncProcessor::ProcessMap& GraphStorageServiceAsyncProcessor::getBinaryProtocolProcessMap() { + return binaryProcessMap_; +} + +const GraphStorageServiceAsyncProcessor::ProcessMap GraphStorageServiceAsyncProcessor::binaryProcessMap_ { + {"getNeighbors", &GraphStorageServiceAsyncProcessor::setUpAndProcess_getNeighbors}, + {"getProps", &GraphStorageServiceAsyncProcessor::setUpAndProcess_getProps}, + {"addVertices", &GraphStorageServiceAsyncProcessor::setUpAndProcess_addVertices}, + {"addEdges", &GraphStorageServiceAsyncProcessor::setUpAndProcess_addEdges}, + {"deleteEdges", &GraphStorageServiceAsyncProcessor::setUpAndProcess_deleteEdges}, + {"deleteVertices", &GraphStorageServiceAsyncProcessor::setUpAndProcess_deleteVertices}, + {"deleteTags", &GraphStorageServiceAsyncProcessor::setUpAndProcess_deleteTags}, + {"updateVertex", &GraphStorageServiceAsyncProcessor::setUpAndProcess_updateVertex}, + {"updateEdge", &GraphStorageServiceAsyncProcessor::setUpAndProcess_updateEdge}, + {"scanVertex", &GraphStorageServiceAsyncProcessor::setUpAndProcess_scanVertex}, + {"scanEdge", &GraphStorageServiceAsyncProcessor::setUpAndProcess_scanEdge}, + {"getUUID", &GraphStorageServiceAsyncProcessor::setUpAndProcess_getUUID}, + {"lookupIndex", &GraphStorageServiceAsyncProcessor::setUpAndProcess_lookupIndex}, + {"lookupAndTraverse", &GraphStorageServiceAsyncProcessor::setUpAndProcess_lookupAndTraverse}, + {"chainUpdateEdge", &GraphStorageServiceAsyncProcessor::setUpAndProcess_chainUpdateEdge}, + {"chainAddEdges", &GraphStorageServiceAsyncProcessor::setUpAndProcess_chainAddEdges}, +}; + +const GraphStorageServiceAsyncProcessor::ProcessMap& GraphStorageServiceAsyncProcessor::getCompactProtocolProcessMap() { + return compactProcessMap_; +} + +const GraphStorageServiceAsyncProcessor::ProcessMap GraphStorageServiceAsyncProcessor::compactProcessMap_ { + {"getNeighbors", &GraphStorageServiceAsyncProcessor::setUpAndProcess_getNeighbors}, + {"getProps", &GraphStorageServiceAsyncProcessor::setUpAndProcess_getProps}, + {"addVertices", &GraphStorageServiceAsyncProcessor::setUpAndProcess_addVertices}, + {"addEdges", &GraphStorageServiceAsyncProcessor::setUpAndProcess_addEdges}, + {"deleteEdges", &GraphStorageServiceAsyncProcessor::setUpAndProcess_deleteEdges}, + {"deleteVertices", &GraphStorageServiceAsyncProcessor::setUpAndProcess_deleteVertices}, + {"deleteTags", &GraphStorageServiceAsyncProcessor::setUpAndProcess_deleteTags}, + {"updateVertex", &GraphStorageServiceAsyncProcessor::setUpAndProcess_updateVertex}, + {"updateEdge", &GraphStorageServiceAsyncProcessor::setUpAndProcess_updateEdge}, + {"scanVertex", &GraphStorageServiceAsyncProcessor::setUpAndProcess_scanVertex}, + {"scanEdge", &GraphStorageServiceAsyncProcessor::setUpAndProcess_scanEdge}, + {"getUUID", &GraphStorageServiceAsyncProcessor::setUpAndProcess_getUUID}, + {"lookupIndex", &GraphStorageServiceAsyncProcessor::setUpAndProcess_lookupIndex}, + {"lookupAndTraverse", &GraphStorageServiceAsyncProcessor::setUpAndProcess_lookupAndTraverse}, + {"chainUpdateEdge", &GraphStorageServiceAsyncProcessor::setUpAndProcess_chainUpdateEdge}, + {"chainAddEdges", &GraphStorageServiceAsyncProcessor::setUpAndProcess_chainAddEdges}, +}; + +}}} // nebula::storage::cpp2 diff --git a/src/interface/gen-cpp2/GraphStorageService.h b/src/interface/gen-cpp2/GraphStorageService.h new file mode 100644 index 00000000..a0bb623e --- /dev/null +++ b/src/interface/gen-cpp2/GraphStorageService.h @@ -0,0 +1,331 @@ +/** + * Autogenerated by Thrift for storage.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#pragma once + +#include + +#include "GraphStorageServiceAsyncClient.h" +#include "storage_types.h" +#include "common_types.h" +#include "meta_types.h" + +namespace folly { + class IOBuf; + class IOBufQueue; +} +namespace apache { namespace thrift { + class Cpp2RequestContext; + class BinaryProtocolReader; + class CompactProtocolReader; + namespace transport { class THeader; } +}} + +namespace nebula { namespace storage { namespace cpp2 { + +class GraphStorageServiceSvAsyncIf { + public: + virtual ~GraphStorageServiceSvAsyncIf() {} + virtual void async_tm_getNeighbors(std::unique_ptr> callback, const ::nebula::storage::cpp2::GetNeighborsRequest& p_req) = 0; + virtual folly::Future< ::nebula::storage::cpp2::GetNeighborsResponse> future_getNeighbors(const ::nebula::storage::cpp2::GetNeighborsRequest& p_req) = 0; + virtual folly::SemiFuture< ::nebula::storage::cpp2::GetNeighborsResponse> semifuture_getNeighbors(const ::nebula::storage::cpp2::GetNeighborsRequest& p_req) = 0; + virtual void async_tm_getProps(std::unique_ptr> callback, const ::nebula::storage::cpp2::GetPropRequest& p_req) = 0; + virtual folly::Future< ::nebula::storage::cpp2::GetPropResponse> future_getProps(const ::nebula::storage::cpp2::GetPropRequest& p_req) = 0; + virtual folly::SemiFuture< ::nebula::storage::cpp2::GetPropResponse> semifuture_getProps(const ::nebula::storage::cpp2::GetPropRequest& p_req) = 0; + virtual void async_tm_addVertices(std::unique_ptr> callback, const ::nebula::storage::cpp2::AddVerticesRequest& p_req) = 0; + virtual folly::Future< ::nebula::storage::cpp2::ExecResponse> future_addVertices(const ::nebula::storage::cpp2::AddVerticesRequest& p_req) = 0; + virtual folly::SemiFuture< ::nebula::storage::cpp2::ExecResponse> semifuture_addVertices(const ::nebula::storage::cpp2::AddVerticesRequest& p_req) = 0; + virtual void async_tm_addEdges(std::unique_ptr> callback, const ::nebula::storage::cpp2::AddEdgesRequest& p_req) = 0; + virtual folly::Future< ::nebula::storage::cpp2::ExecResponse> future_addEdges(const ::nebula::storage::cpp2::AddEdgesRequest& p_req) = 0; + virtual folly::SemiFuture< ::nebula::storage::cpp2::ExecResponse> semifuture_addEdges(const ::nebula::storage::cpp2::AddEdgesRequest& p_req) = 0; + virtual void async_tm_deleteEdges(std::unique_ptr> callback, const ::nebula::storage::cpp2::DeleteEdgesRequest& p_req) = 0; + virtual folly::Future< ::nebula::storage::cpp2::ExecResponse> future_deleteEdges(const ::nebula::storage::cpp2::DeleteEdgesRequest& p_req) = 0; + virtual folly::SemiFuture< ::nebula::storage::cpp2::ExecResponse> semifuture_deleteEdges(const ::nebula::storage::cpp2::DeleteEdgesRequest& p_req) = 0; + virtual void async_tm_deleteVertices(std::unique_ptr> callback, const ::nebula::storage::cpp2::DeleteVerticesRequest& p_req) = 0; + virtual folly::Future< ::nebula::storage::cpp2::ExecResponse> future_deleteVertices(const ::nebula::storage::cpp2::DeleteVerticesRequest& p_req) = 0; + virtual folly::SemiFuture< ::nebula::storage::cpp2::ExecResponse> semifuture_deleteVertices(const ::nebula::storage::cpp2::DeleteVerticesRequest& p_req) = 0; + virtual void async_tm_deleteTags(std::unique_ptr> callback, const ::nebula::storage::cpp2::DeleteTagsRequest& p_req) = 0; + virtual folly::Future< ::nebula::storage::cpp2::ExecResponse> future_deleteTags(const ::nebula::storage::cpp2::DeleteTagsRequest& p_req) = 0; + virtual folly::SemiFuture< ::nebula::storage::cpp2::ExecResponse> semifuture_deleteTags(const ::nebula::storage::cpp2::DeleteTagsRequest& p_req) = 0; + virtual void async_tm_updateVertex(std::unique_ptr> callback, const ::nebula::storage::cpp2::UpdateVertexRequest& p_req) = 0; + virtual folly::Future< ::nebula::storage::cpp2::UpdateResponse> future_updateVertex(const ::nebula::storage::cpp2::UpdateVertexRequest& p_req) = 0; + virtual folly::SemiFuture< ::nebula::storage::cpp2::UpdateResponse> semifuture_updateVertex(const ::nebula::storage::cpp2::UpdateVertexRequest& p_req) = 0; + virtual void async_tm_updateEdge(std::unique_ptr> callback, const ::nebula::storage::cpp2::UpdateEdgeRequest& p_req) = 0; + virtual folly::Future< ::nebula::storage::cpp2::UpdateResponse> future_updateEdge(const ::nebula::storage::cpp2::UpdateEdgeRequest& p_req) = 0; + virtual folly::SemiFuture< ::nebula::storage::cpp2::UpdateResponse> semifuture_updateEdge(const ::nebula::storage::cpp2::UpdateEdgeRequest& p_req) = 0; + virtual void async_tm_scanVertex(std::unique_ptr> callback, const ::nebula::storage::cpp2::ScanVertexRequest& p_req) = 0; + virtual folly::Future< ::nebula::storage::cpp2::ScanVertexResponse> future_scanVertex(const ::nebula::storage::cpp2::ScanVertexRequest& p_req) = 0; + virtual folly::SemiFuture< ::nebula::storage::cpp2::ScanVertexResponse> semifuture_scanVertex(const ::nebula::storage::cpp2::ScanVertexRequest& p_req) = 0; + virtual void async_tm_scanEdge(std::unique_ptr> callback, const ::nebula::storage::cpp2::ScanEdgeRequest& p_req) = 0; + virtual folly::Future< ::nebula::storage::cpp2::ScanEdgeResponse> future_scanEdge(const ::nebula::storage::cpp2::ScanEdgeRequest& p_req) = 0; + virtual folly::SemiFuture< ::nebula::storage::cpp2::ScanEdgeResponse> semifuture_scanEdge(const ::nebula::storage::cpp2::ScanEdgeRequest& p_req) = 0; + virtual void async_tm_getUUID(std::unique_ptr> callback, const ::nebula::storage::cpp2::GetUUIDReq& p_req) = 0; + virtual folly::Future< ::nebula::storage::cpp2::GetUUIDResp> future_getUUID(const ::nebula::storage::cpp2::GetUUIDReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::storage::cpp2::GetUUIDResp> semifuture_getUUID(const ::nebula::storage::cpp2::GetUUIDReq& p_req) = 0; + virtual void async_tm_lookupIndex(std::unique_ptr> callback, const ::nebula::storage::cpp2::LookupIndexRequest& p_req) = 0; + virtual folly::Future< ::nebula::storage::cpp2::LookupIndexResp> future_lookupIndex(const ::nebula::storage::cpp2::LookupIndexRequest& p_req) = 0; + virtual folly::SemiFuture< ::nebula::storage::cpp2::LookupIndexResp> semifuture_lookupIndex(const ::nebula::storage::cpp2::LookupIndexRequest& p_req) = 0; + virtual void async_tm_lookupAndTraverse(std::unique_ptr> callback, const ::nebula::storage::cpp2::LookupAndTraverseRequest& p_req) = 0; + virtual folly::Future< ::nebula::storage::cpp2::GetNeighborsResponse> future_lookupAndTraverse(const ::nebula::storage::cpp2::LookupAndTraverseRequest& p_req) = 0; + virtual folly::SemiFuture< ::nebula::storage::cpp2::GetNeighborsResponse> semifuture_lookupAndTraverse(const ::nebula::storage::cpp2::LookupAndTraverseRequest& p_req) = 0; + virtual void async_tm_chainUpdateEdge(std::unique_ptr> callback, const ::nebula::storage::cpp2::UpdateEdgeRequest& p_req) = 0; + virtual folly::Future< ::nebula::storage::cpp2::UpdateResponse> future_chainUpdateEdge(const ::nebula::storage::cpp2::UpdateEdgeRequest& p_req) = 0; + virtual folly::SemiFuture< ::nebula::storage::cpp2::UpdateResponse> semifuture_chainUpdateEdge(const ::nebula::storage::cpp2::UpdateEdgeRequest& p_req) = 0; + virtual void async_tm_chainAddEdges(std::unique_ptr> callback, const ::nebula::storage::cpp2::AddEdgesRequest& p_req) = 0; + virtual folly::Future< ::nebula::storage::cpp2::ExecResponse> future_chainAddEdges(const ::nebula::storage::cpp2::AddEdgesRequest& p_req) = 0; + virtual folly::SemiFuture< ::nebula::storage::cpp2::ExecResponse> semifuture_chainAddEdges(const ::nebula::storage::cpp2::AddEdgesRequest& p_req) = 0; +}; + +class GraphStorageServiceAsyncProcessor; + +class GraphStorageServiceSvIf : public GraphStorageServiceSvAsyncIf, public apache::thrift::ServerInterface { + public: + typedef GraphStorageServiceAsyncProcessor ProcessorType; + std::unique_ptr getProcessor() override; + + + virtual void getNeighbors( ::nebula::storage::cpp2::GetNeighborsResponse& /*_return*/, const ::nebula::storage::cpp2::GetNeighborsRequest& /*req*/); + folly::Future< ::nebula::storage::cpp2::GetNeighborsResponse> future_getNeighbors(const ::nebula::storage::cpp2::GetNeighborsRequest& p_req) override; + folly::SemiFuture< ::nebula::storage::cpp2::GetNeighborsResponse> semifuture_getNeighbors(const ::nebula::storage::cpp2::GetNeighborsRequest& p_req) override; + void async_tm_getNeighbors(std::unique_ptr> callback, const ::nebula::storage::cpp2::GetNeighborsRequest& p_req) override; + virtual void getProps( ::nebula::storage::cpp2::GetPropResponse& /*_return*/, const ::nebula::storage::cpp2::GetPropRequest& /*req*/); + folly::Future< ::nebula::storage::cpp2::GetPropResponse> future_getProps(const ::nebula::storage::cpp2::GetPropRequest& p_req) override; + folly::SemiFuture< ::nebula::storage::cpp2::GetPropResponse> semifuture_getProps(const ::nebula::storage::cpp2::GetPropRequest& p_req) override; + void async_tm_getProps(std::unique_ptr> callback, const ::nebula::storage::cpp2::GetPropRequest& p_req) override; + virtual void addVertices( ::nebula::storage::cpp2::ExecResponse& /*_return*/, const ::nebula::storage::cpp2::AddVerticesRequest& /*req*/); + folly::Future< ::nebula::storage::cpp2::ExecResponse> future_addVertices(const ::nebula::storage::cpp2::AddVerticesRequest& p_req) override; + folly::SemiFuture< ::nebula::storage::cpp2::ExecResponse> semifuture_addVertices(const ::nebula::storage::cpp2::AddVerticesRequest& p_req) override; + void async_tm_addVertices(std::unique_ptr> callback, const ::nebula::storage::cpp2::AddVerticesRequest& p_req) override; + virtual void addEdges( ::nebula::storage::cpp2::ExecResponse& /*_return*/, const ::nebula::storage::cpp2::AddEdgesRequest& /*req*/); + folly::Future< ::nebula::storage::cpp2::ExecResponse> future_addEdges(const ::nebula::storage::cpp2::AddEdgesRequest& p_req) override; + folly::SemiFuture< ::nebula::storage::cpp2::ExecResponse> semifuture_addEdges(const ::nebula::storage::cpp2::AddEdgesRequest& p_req) override; + void async_tm_addEdges(std::unique_ptr> callback, const ::nebula::storage::cpp2::AddEdgesRequest& p_req) override; + virtual void deleteEdges( ::nebula::storage::cpp2::ExecResponse& /*_return*/, const ::nebula::storage::cpp2::DeleteEdgesRequest& /*req*/); + folly::Future< ::nebula::storage::cpp2::ExecResponse> future_deleteEdges(const ::nebula::storage::cpp2::DeleteEdgesRequest& p_req) override; + folly::SemiFuture< ::nebula::storage::cpp2::ExecResponse> semifuture_deleteEdges(const ::nebula::storage::cpp2::DeleteEdgesRequest& p_req) override; + void async_tm_deleteEdges(std::unique_ptr> callback, const ::nebula::storage::cpp2::DeleteEdgesRequest& p_req) override; + virtual void deleteVertices( ::nebula::storage::cpp2::ExecResponse& /*_return*/, const ::nebula::storage::cpp2::DeleteVerticesRequest& /*req*/); + folly::Future< ::nebula::storage::cpp2::ExecResponse> future_deleteVertices(const ::nebula::storage::cpp2::DeleteVerticesRequest& p_req) override; + folly::SemiFuture< ::nebula::storage::cpp2::ExecResponse> semifuture_deleteVertices(const ::nebula::storage::cpp2::DeleteVerticesRequest& p_req) override; + void async_tm_deleteVertices(std::unique_ptr> callback, const ::nebula::storage::cpp2::DeleteVerticesRequest& p_req) override; + virtual void deleteTags( ::nebula::storage::cpp2::ExecResponse& /*_return*/, const ::nebula::storage::cpp2::DeleteTagsRequest& /*req*/); + folly::Future< ::nebula::storage::cpp2::ExecResponse> future_deleteTags(const ::nebula::storage::cpp2::DeleteTagsRequest& p_req) override; + folly::SemiFuture< ::nebula::storage::cpp2::ExecResponse> semifuture_deleteTags(const ::nebula::storage::cpp2::DeleteTagsRequest& p_req) override; + void async_tm_deleteTags(std::unique_ptr> callback, const ::nebula::storage::cpp2::DeleteTagsRequest& p_req) override; + virtual void updateVertex( ::nebula::storage::cpp2::UpdateResponse& /*_return*/, const ::nebula::storage::cpp2::UpdateVertexRequest& /*req*/); + folly::Future< ::nebula::storage::cpp2::UpdateResponse> future_updateVertex(const ::nebula::storage::cpp2::UpdateVertexRequest& p_req) override; + folly::SemiFuture< ::nebula::storage::cpp2::UpdateResponse> semifuture_updateVertex(const ::nebula::storage::cpp2::UpdateVertexRequest& p_req) override; + void async_tm_updateVertex(std::unique_ptr> callback, const ::nebula::storage::cpp2::UpdateVertexRequest& p_req) override; + virtual void updateEdge( ::nebula::storage::cpp2::UpdateResponse& /*_return*/, const ::nebula::storage::cpp2::UpdateEdgeRequest& /*req*/); + folly::Future< ::nebula::storage::cpp2::UpdateResponse> future_updateEdge(const ::nebula::storage::cpp2::UpdateEdgeRequest& p_req) override; + folly::SemiFuture< ::nebula::storage::cpp2::UpdateResponse> semifuture_updateEdge(const ::nebula::storage::cpp2::UpdateEdgeRequest& p_req) override; + void async_tm_updateEdge(std::unique_ptr> callback, const ::nebula::storage::cpp2::UpdateEdgeRequest& p_req) override; + virtual void scanVertex( ::nebula::storage::cpp2::ScanVertexResponse& /*_return*/, const ::nebula::storage::cpp2::ScanVertexRequest& /*req*/); + folly::Future< ::nebula::storage::cpp2::ScanVertexResponse> future_scanVertex(const ::nebula::storage::cpp2::ScanVertexRequest& p_req) override; + folly::SemiFuture< ::nebula::storage::cpp2::ScanVertexResponse> semifuture_scanVertex(const ::nebula::storage::cpp2::ScanVertexRequest& p_req) override; + void async_tm_scanVertex(std::unique_ptr> callback, const ::nebula::storage::cpp2::ScanVertexRequest& p_req) override; + virtual void scanEdge( ::nebula::storage::cpp2::ScanEdgeResponse& /*_return*/, const ::nebula::storage::cpp2::ScanEdgeRequest& /*req*/); + folly::Future< ::nebula::storage::cpp2::ScanEdgeResponse> future_scanEdge(const ::nebula::storage::cpp2::ScanEdgeRequest& p_req) override; + folly::SemiFuture< ::nebula::storage::cpp2::ScanEdgeResponse> semifuture_scanEdge(const ::nebula::storage::cpp2::ScanEdgeRequest& p_req) override; + void async_tm_scanEdge(std::unique_ptr> callback, const ::nebula::storage::cpp2::ScanEdgeRequest& p_req) override; + virtual void getUUID( ::nebula::storage::cpp2::GetUUIDResp& /*_return*/, const ::nebula::storage::cpp2::GetUUIDReq& /*req*/); + folly::Future< ::nebula::storage::cpp2::GetUUIDResp> future_getUUID(const ::nebula::storage::cpp2::GetUUIDReq& p_req) override; + folly::SemiFuture< ::nebula::storage::cpp2::GetUUIDResp> semifuture_getUUID(const ::nebula::storage::cpp2::GetUUIDReq& p_req) override; + void async_tm_getUUID(std::unique_ptr> callback, const ::nebula::storage::cpp2::GetUUIDReq& p_req) override; + virtual void lookupIndex( ::nebula::storage::cpp2::LookupIndexResp& /*_return*/, const ::nebula::storage::cpp2::LookupIndexRequest& /*req*/); + folly::Future< ::nebula::storage::cpp2::LookupIndexResp> future_lookupIndex(const ::nebula::storage::cpp2::LookupIndexRequest& p_req) override; + folly::SemiFuture< ::nebula::storage::cpp2::LookupIndexResp> semifuture_lookupIndex(const ::nebula::storage::cpp2::LookupIndexRequest& p_req) override; + void async_tm_lookupIndex(std::unique_ptr> callback, const ::nebula::storage::cpp2::LookupIndexRequest& p_req) override; + virtual void lookupAndTraverse( ::nebula::storage::cpp2::GetNeighborsResponse& /*_return*/, const ::nebula::storage::cpp2::LookupAndTraverseRequest& /*req*/); + folly::Future< ::nebula::storage::cpp2::GetNeighborsResponse> future_lookupAndTraverse(const ::nebula::storage::cpp2::LookupAndTraverseRequest& p_req) override; + folly::SemiFuture< ::nebula::storage::cpp2::GetNeighborsResponse> semifuture_lookupAndTraverse(const ::nebula::storage::cpp2::LookupAndTraverseRequest& p_req) override; + void async_tm_lookupAndTraverse(std::unique_ptr> callback, const ::nebula::storage::cpp2::LookupAndTraverseRequest& p_req) override; + virtual void chainUpdateEdge( ::nebula::storage::cpp2::UpdateResponse& /*_return*/, const ::nebula::storage::cpp2::UpdateEdgeRequest& /*req*/); + folly::Future< ::nebula::storage::cpp2::UpdateResponse> future_chainUpdateEdge(const ::nebula::storage::cpp2::UpdateEdgeRequest& p_req) override; + folly::SemiFuture< ::nebula::storage::cpp2::UpdateResponse> semifuture_chainUpdateEdge(const ::nebula::storage::cpp2::UpdateEdgeRequest& p_req) override; + void async_tm_chainUpdateEdge(std::unique_ptr> callback, const ::nebula::storage::cpp2::UpdateEdgeRequest& p_req) override; + virtual void chainAddEdges( ::nebula::storage::cpp2::ExecResponse& /*_return*/, const ::nebula::storage::cpp2::AddEdgesRequest& /*req*/); + folly::Future< ::nebula::storage::cpp2::ExecResponse> future_chainAddEdges(const ::nebula::storage::cpp2::AddEdgesRequest& p_req) override; + folly::SemiFuture< ::nebula::storage::cpp2::ExecResponse> semifuture_chainAddEdges(const ::nebula::storage::cpp2::AddEdgesRequest& p_req) override; + void async_tm_chainAddEdges(std::unique_ptr> callback, const ::nebula::storage::cpp2::AddEdgesRequest& p_req) override; +}; + +class GraphStorageServiceSvNull : public GraphStorageServiceSvIf { + public: + void getNeighbors( ::nebula::storage::cpp2::GetNeighborsResponse& /*_return*/, const ::nebula::storage::cpp2::GetNeighborsRequest& /*req*/) override; + void getProps( ::nebula::storage::cpp2::GetPropResponse& /*_return*/, const ::nebula::storage::cpp2::GetPropRequest& /*req*/) override; + void addVertices( ::nebula::storage::cpp2::ExecResponse& /*_return*/, const ::nebula::storage::cpp2::AddVerticesRequest& /*req*/) override; + void addEdges( ::nebula::storage::cpp2::ExecResponse& /*_return*/, const ::nebula::storage::cpp2::AddEdgesRequest& /*req*/) override; + void deleteEdges( ::nebula::storage::cpp2::ExecResponse& /*_return*/, const ::nebula::storage::cpp2::DeleteEdgesRequest& /*req*/) override; + void deleteVertices( ::nebula::storage::cpp2::ExecResponse& /*_return*/, const ::nebula::storage::cpp2::DeleteVerticesRequest& /*req*/) override; + void deleteTags( ::nebula::storage::cpp2::ExecResponse& /*_return*/, const ::nebula::storage::cpp2::DeleteTagsRequest& /*req*/) override; + void updateVertex( ::nebula::storage::cpp2::UpdateResponse& /*_return*/, const ::nebula::storage::cpp2::UpdateVertexRequest& /*req*/) override; + void updateEdge( ::nebula::storage::cpp2::UpdateResponse& /*_return*/, const ::nebula::storage::cpp2::UpdateEdgeRequest& /*req*/) override; + void scanVertex( ::nebula::storage::cpp2::ScanVertexResponse& /*_return*/, const ::nebula::storage::cpp2::ScanVertexRequest& /*req*/) override; + void scanEdge( ::nebula::storage::cpp2::ScanEdgeResponse& /*_return*/, const ::nebula::storage::cpp2::ScanEdgeRequest& /*req*/) override; + void getUUID( ::nebula::storage::cpp2::GetUUIDResp& /*_return*/, const ::nebula::storage::cpp2::GetUUIDReq& /*req*/) override; + void lookupIndex( ::nebula::storage::cpp2::LookupIndexResp& /*_return*/, const ::nebula::storage::cpp2::LookupIndexRequest& /*req*/) override; + void lookupAndTraverse( ::nebula::storage::cpp2::GetNeighborsResponse& /*_return*/, const ::nebula::storage::cpp2::LookupAndTraverseRequest& /*req*/) override; + void chainUpdateEdge( ::nebula::storage::cpp2::UpdateResponse& /*_return*/, const ::nebula::storage::cpp2::UpdateEdgeRequest& /*req*/) override; + void chainAddEdges( ::nebula::storage::cpp2::ExecResponse& /*_return*/, const ::nebula::storage::cpp2::AddEdgesRequest& /*req*/) override; +}; + +class GraphStorageServiceAsyncProcessor : public ::apache::thrift::GeneratedAsyncProcessor { + public: + const char* getServiceName() override; + void getServiceMetadata(apache::thrift::metadata::ThriftServiceMetadataResponse& response) override; + using BaseAsyncProcessor = void; + protected: + GraphStorageServiceSvIf* iface_; + public: + void processSerializedRequest(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::protocol::PROTOCOL_TYPES protType, apache::thrift::Cpp2RequestContext* context, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) override; + protected: + std::shared_ptr getBaseContextForRequest() override; + public: + using ProcessFunc = GeneratedAsyncProcessor::ProcessFunc; + using ProcessMap = GeneratedAsyncProcessor::ProcessMap; + static const GraphStorageServiceAsyncProcessor::ProcessMap& getBinaryProtocolProcessMap(); + static const GraphStorageServiceAsyncProcessor::ProcessMap& getCompactProtocolProcessMap(); + private: + static const GraphStorageServiceAsyncProcessor::ProcessMap binaryProcessMap_; + static const GraphStorageServiceAsyncProcessor::ProcessMap compactProcessMap_; + private: + template + void setUpAndProcess_getNeighbors(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_getNeighbors(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_getNeighbors(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::storage::cpp2::GetNeighborsResponse const& _return); + template + static void throw_wrapped_getNeighbors(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_getProps(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_getProps(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_getProps(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::storage::cpp2::GetPropResponse const& _return); + template + static void throw_wrapped_getProps(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_addVertices(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_addVertices(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_addVertices(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::storage::cpp2::ExecResponse const& _return); + template + static void throw_wrapped_addVertices(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_addEdges(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_addEdges(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_addEdges(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::storage::cpp2::ExecResponse const& _return); + template + static void throw_wrapped_addEdges(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_deleteEdges(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_deleteEdges(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_deleteEdges(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::storage::cpp2::ExecResponse const& _return); + template + static void throw_wrapped_deleteEdges(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_deleteVertices(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_deleteVertices(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_deleteVertices(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::storage::cpp2::ExecResponse const& _return); + template + static void throw_wrapped_deleteVertices(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_deleteTags(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_deleteTags(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_deleteTags(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::storage::cpp2::ExecResponse const& _return); + template + static void throw_wrapped_deleteTags(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_updateVertex(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_updateVertex(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_updateVertex(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::storage::cpp2::UpdateResponse const& _return); + template + static void throw_wrapped_updateVertex(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_updateEdge(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_updateEdge(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_updateEdge(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::storage::cpp2::UpdateResponse const& _return); + template + static void throw_wrapped_updateEdge(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_scanVertex(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_scanVertex(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_scanVertex(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::storage::cpp2::ScanVertexResponse const& _return); + template + static void throw_wrapped_scanVertex(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_scanEdge(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_scanEdge(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_scanEdge(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::storage::cpp2::ScanEdgeResponse const& _return); + template + static void throw_wrapped_scanEdge(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_getUUID(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_getUUID(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_getUUID(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::storage::cpp2::GetUUIDResp const& _return); + template + static void throw_wrapped_getUUID(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_lookupIndex(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_lookupIndex(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_lookupIndex(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::storage::cpp2::LookupIndexResp const& _return); + template + static void throw_wrapped_lookupIndex(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_lookupAndTraverse(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_lookupAndTraverse(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_lookupAndTraverse(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::storage::cpp2::GetNeighborsResponse const& _return); + template + static void throw_wrapped_lookupAndTraverse(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_chainUpdateEdge(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_chainUpdateEdge(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_chainUpdateEdge(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::storage::cpp2::UpdateResponse const& _return); + template + static void throw_wrapped_chainUpdateEdge(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_chainAddEdges(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_chainAddEdges(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_chainAddEdges(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::storage::cpp2::ExecResponse const& _return); + template + static void throw_wrapped_chainAddEdges(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + public: + GraphStorageServiceAsyncProcessor(GraphStorageServiceSvIf* iface) : + iface_(iface) {} + + virtual ~GraphStorageServiceAsyncProcessor() {} +}; + +}}} // nebula::storage::cpp2 diff --git a/src/interface/gen-cpp2/GraphStorageService.tcc b/src/interface/gen-cpp2/GraphStorageService.tcc new file mode 100644 index 00000000..cd64d048 --- /dev/null +++ b/src/interface/gen-cpp2/GraphStorageService.tcc @@ -0,0 +1,959 @@ +/** + * Autogenerated by Thrift for storage.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#pragma once + +#include "GraphStorageService.h" + +#include + +namespace nebula { namespace storage { namespace cpp2 { +typedef apache::thrift::ThriftPresult> GraphStorageService_getNeighbors_pargs; +typedef apache::thrift::ThriftPresult> GraphStorageService_getNeighbors_presult; +typedef apache::thrift::ThriftPresult> GraphStorageService_getProps_pargs; +typedef apache::thrift::ThriftPresult> GraphStorageService_getProps_presult; +typedef apache::thrift::ThriftPresult> GraphStorageService_addVertices_pargs; +typedef apache::thrift::ThriftPresult> GraphStorageService_addVertices_presult; +typedef apache::thrift::ThriftPresult> GraphStorageService_addEdges_pargs; +typedef apache::thrift::ThriftPresult> GraphStorageService_addEdges_presult; +typedef apache::thrift::ThriftPresult> GraphStorageService_deleteEdges_pargs; +typedef apache::thrift::ThriftPresult> GraphStorageService_deleteEdges_presult; +typedef apache::thrift::ThriftPresult> GraphStorageService_deleteVertices_pargs; +typedef apache::thrift::ThriftPresult> GraphStorageService_deleteVertices_presult; +typedef apache::thrift::ThriftPresult> GraphStorageService_deleteTags_pargs; +typedef apache::thrift::ThriftPresult> GraphStorageService_deleteTags_presult; +typedef apache::thrift::ThriftPresult> GraphStorageService_updateVertex_pargs; +typedef apache::thrift::ThriftPresult> GraphStorageService_updateVertex_presult; +typedef apache::thrift::ThriftPresult> GraphStorageService_updateEdge_pargs; +typedef apache::thrift::ThriftPresult> GraphStorageService_updateEdge_presult; +typedef apache::thrift::ThriftPresult> GraphStorageService_scanVertex_pargs; +typedef apache::thrift::ThriftPresult> GraphStorageService_scanVertex_presult; +typedef apache::thrift::ThriftPresult> GraphStorageService_scanEdge_pargs; +typedef apache::thrift::ThriftPresult> GraphStorageService_scanEdge_presult; +typedef apache::thrift::ThriftPresult> GraphStorageService_getUUID_pargs; +typedef apache::thrift::ThriftPresult> GraphStorageService_getUUID_presult; +typedef apache::thrift::ThriftPresult> GraphStorageService_lookupIndex_pargs; +typedef apache::thrift::ThriftPresult> GraphStorageService_lookupIndex_presult; +typedef apache::thrift::ThriftPresult> GraphStorageService_lookupAndTraverse_pargs; +typedef apache::thrift::ThriftPresult> GraphStorageService_lookupAndTraverse_presult; +typedef apache::thrift::ThriftPresult> GraphStorageService_chainUpdateEdge_pargs; +typedef apache::thrift::ThriftPresult> GraphStorageService_chainUpdateEdge_presult; +typedef apache::thrift::ThriftPresult> GraphStorageService_chainAddEdges_pargs; +typedef apache::thrift::ThriftPresult> GraphStorageService_chainAddEdges_presult; +template +void GraphStorageServiceAsyncProcessor::setUpAndProcess_getNeighbors(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &GraphStorageServiceAsyncProcessor::process_getNeighbors, this); +} + +template +void GraphStorageServiceAsyncProcessor::process_getNeighbors(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + GraphStorageService_getNeighbors_pargs args; + ::nebula::storage::cpp2::GetNeighborsRequest uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "GraphStorageService.getNeighbors", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "getNeighbors"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_getNeighbors, throw_wrapped_getNeighbors, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_getNeighbors(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue GraphStorageServiceAsyncProcessor::return_getNeighbors(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::storage::cpp2::GetNeighborsResponse const& _return) { + ProtocolOut_ prot; + GraphStorageService_getNeighbors_presult result; + result.get<0>().value = const_cast< ::nebula::storage::cpp2::GetNeighborsResponse*>(&_return); + result.setIsSet(0, true); + return serializeResponse("getNeighbors", &prot, protoSeqId, ctx, result); +} + +template +void GraphStorageServiceAsyncProcessor::throw_wrapped_getNeighbors(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "getNeighbors"); + return; + } +} + +template +void GraphStorageServiceAsyncProcessor::setUpAndProcess_getProps(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &GraphStorageServiceAsyncProcessor::process_getProps, this); +} + +template +void GraphStorageServiceAsyncProcessor::process_getProps(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + GraphStorageService_getProps_pargs args; + ::nebula::storage::cpp2::GetPropRequest uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "GraphStorageService.getProps", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "getProps"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_getProps, throw_wrapped_getProps, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_getProps(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue GraphStorageServiceAsyncProcessor::return_getProps(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::storage::cpp2::GetPropResponse const& _return) { + ProtocolOut_ prot; + GraphStorageService_getProps_presult result; + result.get<0>().value = const_cast< ::nebula::storage::cpp2::GetPropResponse*>(&_return); + result.setIsSet(0, true); + return serializeResponse("getProps", &prot, protoSeqId, ctx, result); +} + +template +void GraphStorageServiceAsyncProcessor::throw_wrapped_getProps(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "getProps"); + return; + } +} + +template +void GraphStorageServiceAsyncProcessor::setUpAndProcess_addVertices(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &GraphStorageServiceAsyncProcessor::process_addVertices, this); +} + +template +void GraphStorageServiceAsyncProcessor::process_addVertices(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + GraphStorageService_addVertices_pargs args; + ::nebula::storage::cpp2::AddVerticesRequest uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "GraphStorageService.addVertices", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "addVertices"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_addVertices, throw_wrapped_addVertices, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_addVertices(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue GraphStorageServiceAsyncProcessor::return_addVertices(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::storage::cpp2::ExecResponse const& _return) { + ProtocolOut_ prot; + GraphStorageService_addVertices_presult result; + result.get<0>().value = const_cast< ::nebula::storage::cpp2::ExecResponse*>(&_return); + result.setIsSet(0, true); + return serializeResponse("addVertices", &prot, protoSeqId, ctx, result); +} + +template +void GraphStorageServiceAsyncProcessor::throw_wrapped_addVertices(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "addVertices"); + return; + } +} + +template +void GraphStorageServiceAsyncProcessor::setUpAndProcess_addEdges(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &GraphStorageServiceAsyncProcessor::process_addEdges, this); +} + +template +void GraphStorageServiceAsyncProcessor::process_addEdges(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + GraphStorageService_addEdges_pargs args; + ::nebula::storage::cpp2::AddEdgesRequest uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "GraphStorageService.addEdges", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "addEdges"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_addEdges, throw_wrapped_addEdges, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_addEdges(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue GraphStorageServiceAsyncProcessor::return_addEdges(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::storage::cpp2::ExecResponse const& _return) { + ProtocolOut_ prot; + GraphStorageService_addEdges_presult result; + result.get<0>().value = const_cast< ::nebula::storage::cpp2::ExecResponse*>(&_return); + result.setIsSet(0, true); + return serializeResponse("addEdges", &prot, protoSeqId, ctx, result); +} + +template +void GraphStorageServiceAsyncProcessor::throw_wrapped_addEdges(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "addEdges"); + return; + } +} + +template +void GraphStorageServiceAsyncProcessor::setUpAndProcess_deleteEdges(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &GraphStorageServiceAsyncProcessor::process_deleteEdges, this); +} + +template +void GraphStorageServiceAsyncProcessor::process_deleteEdges(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + GraphStorageService_deleteEdges_pargs args; + ::nebula::storage::cpp2::DeleteEdgesRequest uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "GraphStorageService.deleteEdges", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "deleteEdges"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_deleteEdges, throw_wrapped_deleteEdges, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_deleteEdges(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue GraphStorageServiceAsyncProcessor::return_deleteEdges(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::storage::cpp2::ExecResponse const& _return) { + ProtocolOut_ prot; + GraphStorageService_deleteEdges_presult result; + result.get<0>().value = const_cast< ::nebula::storage::cpp2::ExecResponse*>(&_return); + result.setIsSet(0, true); + return serializeResponse("deleteEdges", &prot, protoSeqId, ctx, result); +} + +template +void GraphStorageServiceAsyncProcessor::throw_wrapped_deleteEdges(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "deleteEdges"); + return; + } +} + +template +void GraphStorageServiceAsyncProcessor::setUpAndProcess_deleteVertices(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &GraphStorageServiceAsyncProcessor::process_deleteVertices, this); +} + +template +void GraphStorageServiceAsyncProcessor::process_deleteVertices(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + GraphStorageService_deleteVertices_pargs args; + ::nebula::storage::cpp2::DeleteVerticesRequest uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "GraphStorageService.deleteVertices", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "deleteVertices"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_deleteVertices, throw_wrapped_deleteVertices, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_deleteVertices(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue GraphStorageServiceAsyncProcessor::return_deleteVertices(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::storage::cpp2::ExecResponse const& _return) { + ProtocolOut_ prot; + GraphStorageService_deleteVertices_presult result; + result.get<0>().value = const_cast< ::nebula::storage::cpp2::ExecResponse*>(&_return); + result.setIsSet(0, true); + return serializeResponse("deleteVertices", &prot, protoSeqId, ctx, result); +} + +template +void GraphStorageServiceAsyncProcessor::throw_wrapped_deleteVertices(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "deleteVertices"); + return; + } +} + +template +void GraphStorageServiceAsyncProcessor::setUpAndProcess_deleteTags(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &GraphStorageServiceAsyncProcessor::process_deleteTags, this); +} + +template +void GraphStorageServiceAsyncProcessor::process_deleteTags(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + GraphStorageService_deleteTags_pargs args; + ::nebula::storage::cpp2::DeleteTagsRequest uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "GraphStorageService.deleteTags", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "deleteTags"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_deleteTags, throw_wrapped_deleteTags, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_deleteTags(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue GraphStorageServiceAsyncProcessor::return_deleteTags(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::storage::cpp2::ExecResponse const& _return) { + ProtocolOut_ prot; + GraphStorageService_deleteTags_presult result; + result.get<0>().value = const_cast< ::nebula::storage::cpp2::ExecResponse*>(&_return); + result.setIsSet(0, true); + return serializeResponse("deleteTags", &prot, protoSeqId, ctx, result); +} + +template +void GraphStorageServiceAsyncProcessor::throw_wrapped_deleteTags(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "deleteTags"); + return; + } +} + +template +void GraphStorageServiceAsyncProcessor::setUpAndProcess_updateVertex(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &GraphStorageServiceAsyncProcessor::process_updateVertex, this); +} + +template +void GraphStorageServiceAsyncProcessor::process_updateVertex(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + GraphStorageService_updateVertex_pargs args; + ::nebula::storage::cpp2::UpdateVertexRequest uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "GraphStorageService.updateVertex", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "updateVertex"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_updateVertex, throw_wrapped_updateVertex, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_updateVertex(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue GraphStorageServiceAsyncProcessor::return_updateVertex(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::storage::cpp2::UpdateResponse const& _return) { + ProtocolOut_ prot; + GraphStorageService_updateVertex_presult result; + result.get<0>().value = const_cast< ::nebula::storage::cpp2::UpdateResponse*>(&_return); + result.setIsSet(0, true); + return serializeResponse("updateVertex", &prot, protoSeqId, ctx, result); +} + +template +void GraphStorageServiceAsyncProcessor::throw_wrapped_updateVertex(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "updateVertex"); + return; + } +} + +template +void GraphStorageServiceAsyncProcessor::setUpAndProcess_updateEdge(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &GraphStorageServiceAsyncProcessor::process_updateEdge, this); +} + +template +void GraphStorageServiceAsyncProcessor::process_updateEdge(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + GraphStorageService_updateEdge_pargs args; + ::nebula::storage::cpp2::UpdateEdgeRequest uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "GraphStorageService.updateEdge", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "updateEdge"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_updateEdge, throw_wrapped_updateEdge, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_updateEdge(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue GraphStorageServiceAsyncProcessor::return_updateEdge(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::storage::cpp2::UpdateResponse const& _return) { + ProtocolOut_ prot; + GraphStorageService_updateEdge_presult result; + result.get<0>().value = const_cast< ::nebula::storage::cpp2::UpdateResponse*>(&_return); + result.setIsSet(0, true); + return serializeResponse("updateEdge", &prot, protoSeqId, ctx, result); +} + +template +void GraphStorageServiceAsyncProcessor::throw_wrapped_updateEdge(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "updateEdge"); + return; + } +} + +template +void GraphStorageServiceAsyncProcessor::setUpAndProcess_scanVertex(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &GraphStorageServiceAsyncProcessor::process_scanVertex, this); +} + +template +void GraphStorageServiceAsyncProcessor::process_scanVertex(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + GraphStorageService_scanVertex_pargs args; + ::nebula::storage::cpp2::ScanVertexRequest uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "GraphStorageService.scanVertex", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "scanVertex"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_scanVertex, throw_wrapped_scanVertex, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_scanVertex(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue GraphStorageServiceAsyncProcessor::return_scanVertex(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::storage::cpp2::ScanVertexResponse const& _return) { + ProtocolOut_ prot; + GraphStorageService_scanVertex_presult result; + result.get<0>().value = const_cast< ::nebula::storage::cpp2::ScanVertexResponse*>(&_return); + result.setIsSet(0, true); + return serializeResponse("scanVertex", &prot, protoSeqId, ctx, result); +} + +template +void GraphStorageServiceAsyncProcessor::throw_wrapped_scanVertex(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "scanVertex"); + return; + } +} + +template +void GraphStorageServiceAsyncProcessor::setUpAndProcess_scanEdge(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &GraphStorageServiceAsyncProcessor::process_scanEdge, this); +} + +template +void GraphStorageServiceAsyncProcessor::process_scanEdge(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + GraphStorageService_scanEdge_pargs args; + ::nebula::storage::cpp2::ScanEdgeRequest uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "GraphStorageService.scanEdge", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "scanEdge"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_scanEdge, throw_wrapped_scanEdge, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_scanEdge(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue GraphStorageServiceAsyncProcessor::return_scanEdge(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::storage::cpp2::ScanEdgeResponse const& _return) { + ProtocolOut_ prot; + GraphStorageService_scanEdge_presult result; + result.get<0>().value = const_cast< ::nebula::storage::cpp2::ScanEdgeResponse*>(&_return); + result.setIsSet(0, true); + return serializeResponse("scanEdge", &prot, protoSeqId, ctx, result); +} + +template +void GraphStorageServiceAsyncProcessor::throw_wrapped_scanEdge(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "scanEdge"); + return; + } +} + +template +void GraphStorageServiceAsyncProcessor::setUpAndProcess_getUUID(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &GraphStorageServiceAsyncProcessor::process_getUUID, this); +} + +template +void GraphStorageServiceAsyncProcessor::process_getUUID(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + GraphStorageService_getUUID_pargs args; + ::nebula::storage::cpp2::GetUUIDReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "GraphStorageService.getUUID", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "getUUID"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_getUUID, throw_wrapped_getUUID, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_getUUID(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue GraphStorageServiceAsyncProcessor::return_getUUID(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::storage::cpp2::GetUUIDResp const& _return) { + ProtocolOut_ prot; + GraphStorageService_getUUID_presult result; + result.get<0>().value = const_cast< ::nebula::storage::cpp2::GetUUIDResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("getUUID", &prot, protoSeqId, ctx, result); +} + +template +void GraphStorageServiceAsyncProcessor::throw_wrapped_getUUID(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "getUUID"); + return; + } +} + +template +void GraphStorageServiceAsyncProcessor::setUpAndProcess_lookupIndex(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &GraphStorageServiceAsyncProcessor::process_lookupIndex, this); +} + +template +void GraphStorageServiceAsyncProcessor::process_lookupIndex(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + GraphStorageService_lookupIndex_pargs args; + ::nebula::storage::cpp2::LookupIndexRequest uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "GraphStorageService.lookupIndex", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "lookupIndex"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_lookupIndex, throw_wrapped_lookupIndex, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_lookupIndex(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue GraphStorageServiceAsyncProcessor::return_lookupIndex(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::storage::cpp2::LookupIndexResp const& _return) { + ProtocolOut_ prot; + GraphStorageService_lookupIndex_presult result; + result.get<0>().value = const_cast< ::nebula::storage::cpp2::LookupIndexResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("lookupIndex", &prot, protoSeqId, ctx, result); +} + +template +void GraphStorageServiceAsyncProcessor::throw_wrapped_lookupIndex(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "lookupIndex"); + return; + } +} + +template +void GraphStorageServiceAsyncProcessor::setUpAndProcess_lookupAndTraverse(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &GraphStorageServiceAsyncProcessor::process_lookupAndTraverse, this); +} + +template +void GraphStorageServiceAsyncProcessor::process_lookupAndTraverse(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + GraphStorageService_lookupAndTraverse_pargs args; + ::nebula::storage::cpp2::LookupAndTraverseRequest uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "GraphStorageService.lookupAndTraverse", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "lookupAndTraverse"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_lookupAndTraverse, throw_wrapped_lookupAndTraverse, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_lookupAndTraverse(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue GraphStorageServiceAsyncProcessor::return_lookupAndTraverse(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::storage::cpp2::GetNeighborsResponse const& _return) { + ProtocolOut_ prot; + GraphStorageService_lookupAndTraverse_presult result; + result.get<0>().value = const_cast< ::nebula::storage::cpp2::GetNeighborsResponse*>(&_return); + result.setIsSet(0, true); + return serializeResponse("lookupAndTraverse", &prot, protoSeqId, ctx, result); +} + +template +void GraphStorageServiceAsyncProcessor::throw_wrapped_lookupAndTraverse(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "lookupAndTraverse"); + return; + } +} + +template +void GraphStorageServiceAsyncProcessor::setUpAndProcess_chainUpdateEdge(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &GraphStorageServiceAsyncProcessor::process_chainUpdateEdge, this); +} + +template +void GraphStorageServiceAsyncProcessor::process_chainUpdateEdge(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + GraphStorageService_chainUpdateEdge_pargs args; + ::nebula::storage::cpp2::UpdateEdgeRequest uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "GraphStorageService.chainUpdateEdge", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "chainUpdateEdge"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_chainUpdateEdge, throw_wrapped_chainUpdateEdge, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_chainUpdateEdge(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue GraphStorageServiceAsyncProcessor::return_chainUpdateEdge(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::storage::cpp2::UpdateResponse const& _return) { + ProtocolOut_ prot; + GraphStorageService_chainUpdateEdge_presult result; + result.get<0>().value = const_cast< ::nebula::storage::cpp2::UpdateResponse*>(&_return); + result.setIsSet(0, true); + return serializeResponse("chainUpdateEdge", &prot, protoSeqId, ctx, result); +} + +template +void GraphStorageServiceAsyncProcessor::throw_wrapped_chainUpdateEdge(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "chainUpdateEdge"); + return; + } +} + +template +void GraphStorageServiceAsyncProcessor::setUpAndProcess_chainAddEdges(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &GraphStorageServiceAsyncProcessor::process_chainAddEdges, this); +} + +template +void GraphStorageServiceAsyncProcessor::process_chainAddEdges(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + GraphStorageService_chainAddEdges_pargs args; + ::nebula::storage::cpp2::AddEdgesRequest uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "GraphStorageService.chainAddEdges", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "chainAddEdges"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_chainAddEdges, throw_wrapped_chainAddEdges, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_chainAddEdges(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue GraphStorageServiceAsyncProcessor::return_chainAddEdges(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::storage::cpp2::ExecResponse const& _return) { + ProtocolOut_ prot; + GraphStorageService_chainAddEdges_presult result; + result.get<0>().value = const_cast< ::nebula::storage::cpp2::ExecResponse*>(&_return); + result.setIsSet(0, true); + return serializeResponse("chainAddEdges", &prot, protoSeqId, ctx, result); +} + +template +void GraphStorageServiceAsyncProcessor::throw_wrapped_chainAddEdges(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "chainAddEdges"); + return; + } +} + + +}}} // nebula::storage::cpp2 diff --git a/src/interface/gen-cpp2/GraphStorageServiceAsyncClient.cpp b/src/interface/gen-cpp2/GraphStorageServiceAsyncClient.cpp new file mode 100644 index 00000000..5ad2848c --- /dev/null +++ b/src/interface/gen-cpp2/GraphStorageServiceAsyncClient.cpp @@ -0,0 +1,2929 @@ +/** + * Autogenerated by Thrift for storage.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ + +#include "GraphStorageServiceAsyncClient.h" + +#include + +namespace nebula { namespace storage { namespace cpp2 { +typedef apache::thrift::ThriftPresult> GraphStorageService_getNeighbors_pargs; +typedef apache::thrift::ThriftPresult> GraphStorageService_getNeighbors_presult; +typedef apache::thrift::ThriftPresult> GraphStorageService_getProps_pargs; +typedef apache::thrift::ThriftPresult> GraphStorageService_getProps_presult; +typedef apache::thrift::ThriftPresult> GraphStorageService_addVertices_pargs; +typedef apache::thrift::ThriftPresult> GraphStorageService_addVertices_presult; +typedef apache::thrift::ThriftPresult> GraphStorageService_addEdges_pargs; +typedef apache::thrift::ThriftPresult> GraphStorageService_addEdges_presult; +typedef apache::thrift::ThriftPresult> GraphStorageService_deleteEdges_pargs; +typedef apache::thrift::ThriftPresult> GraphStorageService_deleteEdges_presult; +typedef apache::thrift::ThriftPresult> GraphStorageService_deleteVertices_pargs; +typedef apache::thrift::ThriftPresult> GraphStorageService_deleteVertices_presult; +typedef apache::thrift::ThriftPresult> GraphStorageService_deleteTags_pargs; +typedef apache::thrift::ThriftPresult> GraphStorageService_deleteTags_presult; +typedef apache::thrift::ThriftPresult> GraphStorageService_updateVertex_pargs; +typedef apache::thrift::ThriftPresult> GraphStorageService_updateVertex_presult; +typedef apache::thrift::ThriftPresult> GraphStorageService_updateEdge_pargs; +typedef apache::thrift::ThriftPresult> GraphStorageService_updateEdge_presult; +typedef apache::thrift::ThriftPresult> GraphStorageService_scanVertex_pargs; +typedef apache::thrift::ThriftPresult> GraphStorageService_scanVertex_presult; +typedef apache::thrift::ThriftPresult> GraphStorageService_scanEdge_pargs; +typedef apache::thrift::ThriftPresult> GraphStorageService_scanEdge_presult; +typedef apache::thrift::ThriftPresult> GraphStorageService_getUUID_pargs; +typedef apache::thrift::ThriftPresult> GraphStorageService_getUUID_presult; +typedef apache::thrift::ThriftPresult> GraphStorageService_lookupIndex_pargs; +typedef apache::thrift::ThriftPresult> GraphStorageService_lookupIndex_presult; +typedef apache::thrift::ThriftPresult> GraphStorageService_lookupAndTraverse_pargs; +typedef apache::thrift::ThriftPresult> GraphStorageService_lookupAndTraverse_presult; +typedef apache::thrift::ThriftPresult> GraphStorageService_chainUpdateEdge_pargs; +typedef apache::thrift::ThriftPresult> GraphStorageService_chainUpdateEdge_presult; +typedef apache::thrift::ThriftPresult> GraphStorageService_chainAddEdges_pargs; +typedef apache::thrift::ThriftPresult> GraphStorageService_chainAddEdges_presult; + +template +void GraphStorageServiceAsyncClient::getNeighborsT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::GetNeighborsRequest& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + GraphStorageService_getNeighbors_pargs args; + args.get<0>().value = const_cast< ::nebula::storage::cpp2::GetNeighborsRequest*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "getNeighbors"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void GraphStorageServiceAsyncClient::getPropsT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::GetPropRequest& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + GraphStorageService_getProps_pargs args; + args.get<0>().value = const_cast< ::nebula::storage::cpp2::GetPropRequest*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "getProps"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void GraphStorageServiceAsyncClient::addVerticesT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::AddVerticesRequest& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + GraphStorageService_addVertices_pargs args; + args.get<0>().value = const_cast< ::nebula::storage::cpp2::AddVerticesRequest*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "addVertices"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void GraphStorageServiceAsyncClient::addEdgesT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::AddEdgesRequest& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + GraphStorageService_addEdges_pargs args; + args.get<0>().value = const_cast< ::nebula::storage::cpp2::AddEdgesRequest*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "addEdges"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void GraphStorageServiceAsyncClient::deleteEdgesT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::DeleteEdgesRequest& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + GraphStorageService_deleteEdges_pargs args; + args.get<0>().value = const_cast< ::nebula::storage::cpp2::DeleteEdgesRequest*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "deleteEdges"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void GraphStorageServiceAsyncClient::deleteVerticesT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::DeleteVerticesRequest& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + GraphStorageService_deleteVertices_pargs args; + args.get<0>().value = const_cast< ::nebula::storage::cpp2::DeleteVerticesRequest*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "deleteVertices"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void GraphStorageServiceAsyncClient::deleteTagsT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::DeleteTagsRequest& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + GraphStorageService_deleteTags_pargs args; + args.get<0>().value = const_cast< ::nebula::storage::cpp2::DeleteTagsRequest*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "deleteTags"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void GraphStorageServiceAsyncClient::updateVertexT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::UpdateVertexRequest& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + GraphStorageService_updateVertex_pargs args; + args.get<0>().value = const_cast< ::nebula::storage::cpp2::UpdateVertexRequest*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "updateVertex"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void GraphStorageServiceAsyncClient::updateEdgeT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::UpdateEdgeRequest& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + GraphStorageService_updateEdge_pargs args; + args.get<0>().value = const_cast< ::nebula::storage::cpp2::UpdateEdgeRequest*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "updateEdge"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void GraphStorageServiceAsyncClient::scanVertexT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::ScanVertexRequest& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + GraphStorageService_scanVertex_pargs args; + args.get<0>().value = const_cast< ::nebula::storage::cpp2::ScanVertexRequest*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "scanVertex"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void GraphStorageServiceAsyncClient::scanEdgeT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::ScanEdgeRequest& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + GraphStorageService_scanEdge_pargs args; + args.get<0>().value = const_cast< ::nebula::storage::cpp2::ScanEdgeRequest*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "scanEdge"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void GraphStorageServiceAsyncClient::getUUIDT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::GetUUIDReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + GraphStorageService_getUUID_pargs args; + args.get<0>().value = const_cast< ::nebula::storage::cpp2::GetUUIDReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "getUUID"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void GraphStorageServiceAsyncClient::lookupIndexT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::LookupIndexRequest& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + GraphStorageService_lookupIndex_pargs args; + args.get<0>().value = const_cast< ::nebula::storage::cpp2::LookupIndexRequest*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "lookupIndex"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void GraphStorageServiceAsyncClient::lookupAndTraverseT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::LookupAndTraverseRequest& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + GraphStorageService_lookupAndTraverse_pargs args; + args.get<0>().value = const_cast< ::nebula::storage::cpp2::LookupAndTraverseRequest*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "lookupAndTraverse"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void GraphStorageServiceAsyncClient::chainUpdateEdgeT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::UpdateEdgeRequest& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + GraphStorageService_chainUpdateEdge_pargs args; + args.get<0>().value = const_cast< ::nebula::storage::cpp2::UpdateEdgeRequest*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "chainUpdateEdge"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void GraphStorageServiceAsyncClient::chainAddEdgesT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::AddEdgesRequest& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + GraphStorageService_chainAddEdges_pargs args; + args.get<0>().value = const_cast< ::nebula::storage::cpp2::AddEdgesRequest*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "chainAddEdges"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + + + +void GraphStorageServiceAsyncClient::getNeighbors(std::unique_ptr callback, const ::nebula::storage::cpp2::GetNeighborsRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + getNeighbors(rpcOptions, std::move(callback), p_req); +} + +void GraphStorageServiceAsyncClient::getNeighbors(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::storage::cpp2::GetNeighborsRequest& p_req) { + auto ctx = getNeighborsCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + getNeighborsImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void GraphStorageServiceAsyncClient::getNeighborsImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::GetNeighborsRequest& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + getNeighborsT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + getNeighborsT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> GraphStorageServiceAsyncClient::getNeighborsCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "GraphStorageService.getNeighbors"); +} + +void GraphStorageServiceAsyncClient::sync_getNeighbors( ::nebula::storage::cpp2::GetNeighborsResponse& _return, const ::nebula::storage::cpp2::GetNeighborsRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_getNeighbors(rpcOptions, _return, p_req); +} + +void GraphStorageServiceAsyncClient::sync_getNeighbors(apache::thrift::RpcOptions& rpcOptions, ::nebula::storage::cpp2::GetNeighborsResponse& _return, const ::nebula::storage::cpp2::GetNeighborsRequest& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = getNeighborsCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + getNeighborsImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_getNeighbors(_return, returnState); + }); +} + + +folly::Future< ::nebula::storage::cpp2::GetNeighborsResponse> GraphStorageServiceAsyncClient::future_getNeighbors(const ::nebula::storage::cpp2::GetNeighborsRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_getNeighbors(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::storage::cpp2::GetNeighborsResponse> GraphStorageServiceAsyncClient::semifuture_getNeighbors(const ::nebula::storage::cpp2::GetNeighborsRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_getNeighbors(rpcOptions, p_req); +} + +folly::Future< ::nebula::storage::cpp2::GetNeighborsResponse> GraphStorageServiceAsyncClient::future_getNeighbors(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::GetNeighborsRequest& p_req) { + folly::Promise< ::nebula::storage::cpp2::GetNeighborsResponse> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_getNeighbors, channel_); + getNeighbors(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::storage::cpp2::GetNeighborsResponse> GraphStorageServiceAsyncClient::semifuture_getNeighbors(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::GetNeighborsRequest& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_getNeighbors, channel_); + auto callback = std::move(callbackAndFuture.first); + getNeighbors(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> GraphStorageServiceAsyncClient::header_future_getNeighbors(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::GetNeighborsRequest& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_getNeighbors, channel_); + getNeighbors(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> GraphStorageServiceAsyncClient::header_semifuture_getNeighbors(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::GetNeighborsRequest& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_getNeighbors, channel_); + auto callback = std::move(callbackAndFuture.first); + getNeighbors(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void GraphStorageServiceAsyncClient::getNeighbors(folly::Function callback, const ::nebula::storage::cpp2::GetNeighborsRequest& p_req) { + getNeighbors(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper GraphStorageServiceAsyncClient::recv_wrapped_getNeighbors( ::nebula::storage::cpp2::GetNeighborsResponse& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = GraphStorageService_getNeighbors_presult; + constexpr auto const fname = "getNeighbors"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void GraphStorageServiceAsyncClient::recv_getNeighbors( ::nebula::storage::cpp2::GetNeighborsResponse& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_getNeighbors(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void GraphStorageServiceAsyncClient::recv_instance_getNeighbors( ::nebula::storage::cpp2::GetNeighborsResponse& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_getNeighbors(_return, state); +} + +folly::exception_wrapper GraphStorageServiceAsyncClient::recv_instance_wrapped_getNeighbors( ::nebula::storage::cpp2::GetNeighborsResponse& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_getNeighbors(_return, state); +} + +void GraphStorageServiceAsyncClient::getProps(std::unique_ptr callback, const ::nebula::storage::cpp2::GetPropRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + getProps(rpcOptions, std::move(callback), p_req); +} + +void GraphStorageServiceAsyncClient::getProps(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::storage::cpp2::GetPropRequest& p_req) { + auto ctx = getPropsCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + getPropsImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void GraphStorageServiceAsyncClient::getPropsImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::GetPropRequest& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + getPropsT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + getPropsT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> GraphStorageServiceAsyncClient::getPropsCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "GraphStorageService.getProps"); +} + +void GraphStorageServiceAsyncClient::sync_getProps( ::nebula::storage::cpp2::GetPropResponse& _return, const ::nebula::storage::cpp2::GetPropRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_getProps(rpcOptions, _return, p_req); +} + +void GraphStorageServiceAsyncClient::sync_getProps(apache::thrift::RpcOptions& rpcOptions, ::nebula::storage::cpp2::GetPropResponse& _return, const ::nebula::storage::cpp2::GetPropRequest& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = getPropsCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + getPropsImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_getProps(_return, returnState); + }); +} + + +folly::Future< ::nebula::storage::cpp2::GetPropResponse> GraphStorageServiceAsyncClient::future_getProps(const ::nebula::storage::cpp2::GetPropRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_getProps(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::storage::cpp2::GetPropResponse> GraphStorageServiceAsyncClient::semifuture_getProps(const ::nebula::storage::cpp2::GetPropRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_getProps(rpcOptions, p_req); +} + +folly::Future< ::nebula::storage::cpp2::GetPropResponse> GraphStorageServiceAsyncClient::future_getProps(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::GetPropRequest& p_req) { + folly::Promise< ::nebula::storage::cpp2::GetPropResponse> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_getProps, channel_); + getProps(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::storage::cpp2::GetPropResponse> GraphStorageServiceAsyncClient::semifuture_getProps(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::GetPropRequest& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_getProps, channel_); + auto callback = std::move(callbackAndFuture.first); + getProps(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> GraphStorageServiceAsyncClient::header_future_getProps(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::GetPropRequest& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_getProps, channel_); + getProps(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> GraphStorageServiceAsyncClient::header_semifuture_getProps(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::GetPropRequest& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_getProps, channel_); + auto callback = std::move(callbackAndFuture.first); + getProps(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void GraphStorageServiceAsyncClient::getProps(folly::Function callback, const ::nebula::storage::cpp2::GetPropRequest& p_req) { + getProps(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper GraphStorageServiceAsyncClient::recv_wrapped_getProps( ::nebula::storage::cpp2::GetPropResponse& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = GraphStorageService_getProps_presult; + constexpr auto const fname = "getProps"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void GraphStorageServiceAsyncClient::recv_getProps( ::nebula::storage::cpp2::GetPropResponse& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_getProps(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void GraphStorageServiceAsyncClient::recv_instance_getProps( ::nebula::storage::cpp2::GetPropResponse& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_getProps(_return, state); +} + +folly::exception_wrapper GraphStorageServiceAsyncClient::recv_instance_wrapped_getProps( ::nebula::storage::cpp2::GetPropResponse& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_getProps(_return, state); +} + +void GraphStorageServiceAsyncClient::addVertices(std::unique_ptr callback, const ::nebula::storage::cpp2::AddVerticesRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + addVertices(rpcOptions, std::move(callback), p_req); +} + +void GraphStorageServiceAsyncClient::addVertices(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::storage::cpp2::AddVerticesRequest& p_req) { + auto ctx = addVerticesCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + addVerticesImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void GraphStorageServiceAsyncClient::addVerticesImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::AddVerticesRequest& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + addVerticesT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + addVerticesT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> GraphStorageServiceAsyncClient::addVerticesCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "GraphStorageService.addVertices"); +} + +void GraphStorageServiceAsyncClient::sync_addVertices( ::nebula::storage::cpp2::ExecResponse& _return, const ::nebula::storage::cpp2::AddVerticesRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_addVertices(rpcOptions, _return, p_req); +} + +void GraphStorageServiceAsyncClient::sync_addVertices(apache::thrift::RpcOptions& rpcOptions, ::nebula::storage::cpp2::ExecResponse& _return, const ::nebula::storage::cpp2::AddVerticesRequest& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = addVerticesCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + addVerticesImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_addVertices(_return, returnState); + }); +} + + +folly::Future< ::nebula::storage::cpp2::ExecResponse> GraphStorageServiceAsyncClient::future_addVertices(const ::nebula::storage::cpp2::AddVerticesRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_addVertices(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::storage::cpp2::ExecResponse> GraphStorageServiceAsyncClient::semifuture_addVertices(const ::nebula::storage::cpp2::AddVerticesRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_addVertices(rpcOptions, p_req); +} + +folly::Future< ::nebula::storage::cpp2::ExecResponse> GraphStorageServiceAsyncClient::future_addVertices(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::AddVerticesRequest& p_req) { + folly::Promise< ::nebula::storage::cpp2::ExecResponse> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_addVertices, channel_); + addVertices(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::storage::cpp2::ExecResponse> GraphStorageServiceAsyncClient::semifuture_addVertices(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::AddVerticesRequest& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_addVertices, channel_); + auto callback = std::move(callbackAndFuture.first); + addVertices(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> GraphStorageServiceAsyncClient::header_future_addVertices(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::AddVerticesRequest& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_addVertices, channel_); + addVertices(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> GraphStorageServiceAsyncClient::header_semifuture_addVertices(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::AddVerticesRequest& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_addVertices, channel_); + auto callback = std::move(callbackAndFuture.first); + addVertices(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void GraphStorageServiceAsyncClient::addVertices(folly::Function callback, const ::nebula::storage::cpp2::AddVerticesRequest& p_req) { + addVertices(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper GraphStorageServiceAsyncClient::recv_wrapped_addVertices( ::nebula::storage::cpp2::ExecResponse& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = GraphStorageService_addVertices_presult; + constexpr auto const fname = "addVertices"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void GraphStorageServiceAsyncClient::recv_addVertices( ::nebula::storage::cpp2::ExecResponse& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_addVertices(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void GraphStorageServiceAsyncClient::recv_instance_addVertices( ::nebula::storage::cpp2::ExecResponse& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_addVertices(_return, state); +} + +folly::exception_wrapper GraphStorageServiceAsyncClient::recv_instance_wrapped_addVertices( ::nebula::storage::cpp2::ExecResponse& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_addVertices(_return, state); +} + +void GraphStorageServiceAsyncClient::addEdges(std::unique_ptr callback, const ::nebula::storage::cpp2::AddEdgesRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + addEdges(rpcOptions, std::move(callback), p_req); +} + +void GraphStorageServiceAsyncClient::addEdges(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::storage::cpp2::AddEdgesRequest& p_req) { + auto ctx = addEdgesCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + addEdgesImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void GraphStorageServiceAsyncClient::addEdgesImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::AddEdgesRequest& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + addEdgesT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + addEdgesT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> GraphStorageServiceAsyncClient::addEdgesCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "GraphStorageService.addEdges"); +} + +void GraphStorageServiceAsyncClient::sync_addEdges( ::nebula::storage::cpp2::ExecResponse& _return, const ::nebula::storage::cpp2::AddEdgesRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_addEdges(rpcOptions, _return, p_req); +} + +void GraphStorageServiceAsyncClient::sync_addEdges(apache::thrift::RpcOptions& rpcOptions, ::nebula::storage::cpp2::ExecResponse& _return, const ::nebula::storage::cpp2::AddEdgesRequest& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = addEdgesCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + addEdgesImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_addEdges(_return, returnState); + }); +} + + +folly::Future< ::nebula::storage::cpp2::ExecResponse> GraphStorageServiceAsyncClient::future_addEdges(const ::nebula::storage::cpp2::AddEdgesRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_addEdges(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::storage::cpp2::ExecResponse> GraphStorageServiceAsyncClient::semifuture_addEdges(const ::nebula::storage::cpp2::AddEdgesRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_addEdges(rpcOptions, p_req); +} + +folly::Future< ::nebula::storage::cpp2::ExecResponse> GraphStorageServiceAsyncClient::future_addEdges(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::AddEdgesRequest& p_req) { + folly::Promise< ::nebula::storage::cpp2::ExecResponse> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_addEdges, channel_); + addEdges(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::storage::cpp2::ExecResponse> GraphStorageServiceAsyncClient::semifuture_addEdges(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::AddEdgesRequest& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_addEdges, channel_); + auto callback = std::move(callbackAndFuture.first); + addEdges(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> GraphStorageServiceAsyncClient::header_future_addEdges(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::AddEdgesRequest& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_addEdges, channel_); + addEdges(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> GraphStorageServiceAsyncClient::header_semifuture_addEdges(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::AddEdgesRequest& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_addEdges, channel_); + auto callback = std::move(callbackAndFuture.first); + addEdges(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void GraphStorageServiceAsyncClient::addEdges(folly::Function callback, const ::nebula::storage::cpp2::AddEdgesRequest& p_req) { + addEdges(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper GraphStorageServiceAsyncClient::recv_wrapped_addEdges( ::nebula::storage::cpp2::ExecResponse& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = GraphStorageService_addEdges_presult; + constexpr auto const fname = "addEdges"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void GraphStorageServiceAsyncClient::recv_addEdges( ::nebula::storage::cpp2::ExecResponse& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_addEdges(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void GraphStorageServiceAsyncClient::recv_instance_addEdges( ::nebula::storage::cpp2::ExecResponse& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_addEdges(_return, state); +} + +folly::exception_wrapper GraphStorageServiceAsyncClient::recv_instance_wrapped_addEdges( ::nebula::storage::cpp2::ExecResponse& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_addEdges(_return, state); +} + +void GraphStorageServiceAsyncClient::deleteEdges(std::unique_ptr callback, const ::nebula::storage::cpp2::DeleteEdgesRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + deleteEdges(rpcOptions, std::move(callback), p_req); +} + +void GraphStorageServiceAsyncClient::deleteEdges(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::storage::cpp2::DeleteEdgesRequest& p_req) { + auto ctx = deleteEdgesCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + deleteEdgesImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void GraphStorageServiceAsyncClient::deleteEdgesImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::DeleteEdgesRequest& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + deleteEdgesT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + deleteEdgesT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> GraphStorageServiceAsyncClient::deleteEdgesCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "GraphStorageService.deleteEdges"); +} + +void GraphStorageServiceAsyncClient::sync_deleteEdges( ::nebula::storage::cpp2::ExecResponse& _return, const ::nebula::storage::cpp2::DeleteEdgesRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_deleteEdges(rpcOptions, _return, p_req); +} + +void GraphStorageServiceAsyncClient::sync_deleteEdges(apache::thrift::RpcOptions& rpcOptions, ::nebula::storage::cpp2::ExecResponse& _return, const ::nebula::storage::cpp2::DeleteEdgesRequest& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = deleteEdgesCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + deleteEdgesImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_deleteEdges(_return, returnState); + }); +} + + +folly::Future< ::nebula::storage::cpp2::ExecResponse> GraphStorageServiceAsyncClient::future_deleteEdges(const ::nebula::storage::cpp2::DeleteEdgesRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_deleteEdges(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::storage::cpp2::ExecResponse> GraphStorageServiceAsyncClient::semifuture_deleteEdges(const ::nebula::storage::cpp2::DeleteEdgesRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_deleteEdges(rpcOptions, p_req); +} + +folly::Future< ::nebula::storage::cpp2::ExecResponse> GraphStorageServiceAsyncClient::future_deleteEdges(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::DeleteEdgesRequest& p_req) { + folly::Promise< ::nebula::storage::cpp2::ExecResponse> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_deleteEdges, channel_); + deleteEdges(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::storage::cpp2::ExecResponse> GraphStorageServiceAsyncClient::semifuture_deleteEdges(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::DeleteEdgesRequest& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_deleteEdges, channel_); + auto callback = std::move(callbackAndFuture.first); + deleteEdges(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> GraphStorageServiceAsyncClient::header_future_deleteEdges(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::DeleteEdgesRequest& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_deleteEdges, channel_); + deleteEdges(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> GraphStorageServiceAsyncClient::header_semifuture_deleteEdges(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::DeleteEdgesRequest& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_deleteEdges, channel_); + auto callback = std::move(callbackAndFuture.first); + deleteEdges(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void GraphStorageServiceAsyncClient::deleteEdges(folly::Function callback, const ::nebula::storage::cpp2::DeleteEdgesRequest& p_req) { + deleteEdges(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper GraphStorageServiceAsyncClient::recv_wrapped_deleteEdges( ::nebula::storage::cpp2::ExecResponse& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = GraphStorageService_deleteEdges_presult; + constexpr auto const fname = "deleteEdges"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void GraphStorageServiceAsyncClient::recv_deleteEdges( ::nebula::storage::cpp2::ExecResponse& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_deleteEdges(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void GraphStorageServiceAsyncClient::recv_instance_deleteEdges( ::nebula::storage::cpp2::ExecResponse& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_deleteEdges(_return, state); +} + +folly::exception_wrapper GraphStorageServiceAsyncClient::recv_instance_wrapped_deleteEdges( ::nebula::storage::cpp2::ExecResponse& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_deleteEdges(_return, state); +} + +void GraphStorageServiceAsyncClient::deleteVertices(std::unique_ptr callback, const ::nebula::storage::cpp2::DeleteVerticesRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + deleteVertices(rpcOptions, std::move(callback), p_req); +} + +void GraphStorageServiceAsyncClient::deleteVertices(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::storage::cpp2::DeleteVerticesRequest& p_req) { + auto ctx = deleteVerticesCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + deleteVerticesImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void GraphStorageServiceAsyncClient::deleteVerticesImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::DeleteVerticesRequest& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + deleteVerticesT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + deleteVerticesT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> GraphStorageServiceAsyncClient::deleteVerticesCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "GraphStorageService.deleteVertices"); +} + +void GraphStorageServiceAsyncClient::sync_deleteVertices( ::nebula::storage::cpp2::ExecResponse& _return, const ::nebula::storage::cpp2::DeleteVerticesRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_deleteVertices(rpcOptions, _return, p_req); +} + +void GraphStorageServiceAsyncClient::sync_deleteVertices(apache::thrift::RpcOptions& rpcOptions, ::nebula::storage::cpp2::ExecResponse& _return, const ::nebula::storage::cpp2::DeleteVerticesRequest& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = deleteVerticesCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + deleteVerticesImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_deleteVertices(_return, returnState); + }); +} + + +folly::Future< ::nebula::storage::cpp2::ExecResponse> GraphStorageServiceAsyncClient::future_deleteVertices(const ::nebula::storage::cpp2::DeleteVerticesRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_deleteVertices(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::storage::cpp2::ExecResponse> GraphStorageServiceAsyncClient::semifuture_deleteVertices(const ::nebula::storage::cpp2::DeleteVerticesRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_deleteVertices(rpcOptions, p_req); +} + +folly::Future< ::nebula::storage::cpp2::ExecResponse> GraphStorageServiceAsyncClient::future_deleteVertices(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::DeleteVerticesRequest& p_req) { + folly::Promise< ::nebula::storage::cpp2::ExecResponse> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_deleteVertices, channel_); + deleteVertices(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::storage::cpp2::ExecResponse> GraphStorageServiceAsyncClient::semifuture_deleteVertices(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::DeleteVerticesRequest& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_deleteVertices, channel_); + auto callback = std::move(callbackAndFuture.first); + deleteVertices(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> GraphStorageServiceAsyncClient::header_future_deleteVertices(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::DeleteVerticesRequest& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_deleteVertices, channel_); + deleteVertices(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> GraphStorageServiceAsyncClient::header_semifuture_deleteVertices(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::DeleteVerticesRequest& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_deleteVertices, channel_); + auto callback = std::move(callbackAndFuture.first); + deleteVertices(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void GraphStorageServiceAsyncClient::deleteVertices(folly::Function callback, const ::nebula::storage::cpp2::DeleteVerticesRequest& p_req) { + deleteVertices(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper GraphStorageServiceAsyncClient::recv_wrapped_deleteVertices( ::nebula::storage::cpp2::ExecResponse& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = GraphStorageService_deleteVertices_presult; + constexpr auto const fname = "deleteVertices"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void GraphStorageServiceAsyncClient::recv_deleteVertices( ::nebula::storage::cpp2::ExecResponse& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_deleteVertices(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void GraphStorageServiceAsyncClient::recv_instance_deleteVertices( ::nebula::storage::cpp2::ExecResponse& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_deleteVertices(_return, state); +} + +folly::exception_wrapper GraphStorageServiceAsyncClient::recv_instance_wrapped_deleteVertices( ::nebula::storage::cpp2::ExecResponse& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_deleteVertices(_return, state); +} + +void GraphStorageServiceAsyncClient::deleteTags(std::unique_ptr callback, const ::nebula::storage::cpp2::DeleteTagsRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + deleteTags(rpcOptions, std::move(callback), p_req); +} + +void GraphStorageServiceAsyncClient::deleteTags(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::storage::cpp2::DeleteTagsRequest& p_req) { + auto ctx = deleteTagsCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + deleteTagsImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void GraphStorageServiceAsyncClient::deleteTagsImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::DeleteTagsRequest& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + deleteTagsT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + deleteTagsT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> GraphStorageServiceAsyncClient::deleteTagsCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "GraphStorageService.deleteTags"); +} + +void GraphStorageServiceAsyncClient::sync_deleteTags( ::nebula::storage::cpp2::ExecResponse& _return, const ::nebula::storage::cpp2::DeleteTagsRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_deleteTags(rpcOptions, _return, p_req); +} + +void GraphStorageServiceAsyncClient::sync_deleteTags(apache::thrift::RpcOptions& rpcOptions, ::nebula::storage::cpp2::ExecResponse& _return, const ::nebula::storage::cpp2::DeleteTagsRequest& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = deleteTagsCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + deleteTagsImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_deleteTags(_return, returnState); + }); +} + + +folly::Future< ::nebula::storage::cpp2::ExecResponse> GraphStorageServiceAsyncClient::future_deleteTags(const ::nebula::storage::cpp2::DeleteTagsRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_deleteTags(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::storage::cpp2::ExecResponse> GraphStorageServiceAsyncClient::semifuture_deleteTags(const ::nebula::storage::cpp2::DeleteTagsRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_deleteTags(rpcOptions, p_req); +} + +folly::Future< ::nebula::storage::cpp2::ExecResponse> GraphStorageServiceAsyncClient::future_deleteTags(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::DeleteTagsRequest& p_req) { + folly::Promise< ::nebula::storage::cpp2::ExecResponse> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_deleteTags, channel_); + deleteTags(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::storage::cpp2::ExecResponse> GraphStorageServiceAsyncClient::semifuture_deleteTags(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::DeleteTagsRequest& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_deleteTags, channel_); + auto callback = std::move(callbackAndFuture.first); + deleteTags(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> GraphStorageServiceAsyncClient::header_future_deleteTags(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::DeleteTagsRequest& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_deleteTags, channel_); + deleteTags(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> GraphStorageServiceAsyncClient::header_semifuture_deleteTags(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::DeleteTagsRequest& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_deleteTags, channel_); + auto callback = std::move(callbackAndFuture.first); + deleteTags(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void GraphStorageServiceAsyncClient::deleteTags(folly::Function callback, const ::nebula::storage::cpp2::DeleteTagsRequest& p_req) { + deleteTags(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper GraphStorageServiceAsyncClient::recv_wrapped_deleteTags( ::nebula::storage::cpp2::ExecResponse& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = GraphStorageService_deleteTags_presult; + constexpr auto const fname = "deleteTags"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void GraphStorageServiceAsyncClient::recv_deleteTags( ::nebula::storage::cpp2::ExecResponse& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_deleteTags(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void GraphStorageServiceAsyncClient::recv_instance_deleteTags( ::nebula::storage::cpp2::ExecResponse& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_deleteTags(_return, state); +} + +folly::exception_wrapper GraphStorageServiceAsyncClient::recv_instance_wrapped_deleteTags( ::nebula::storage::cpp2::ExecResponse& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_deleteTags(_return, state); +} + +void GraphStorageServiceAsyncClient::updateVertex(std::unique_ptr callback, const ::nebula::storage::cpp2::UpdateVertexRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + updateVertex(rpcOptions, std::move(callback), p_req); +} + +void GraphStorageServiceAsyncClient::updateVertex(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::storage::cpp2::UpdateVertexRequest& p_req) { + auto ctx = updateVertexCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + updateVertexImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void GraphStorageServiceAsyncClient::updateVertexImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::UpdateVertexRequest& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + updateVertexT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + updateVertexT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> GraphStorageServiceAsyncClient::updateVertexCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "GraphStorageService.updateVertex"); +} + +void GraphStorageServiceAsyncClient::sync_updateVertex( ::nebula::storage::cpp2::UpdateResponse& _return, const ::nebula::storage::cpp2::UpdateVertexRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_updateVertex(rpcOptions, _return, p_req); +} + +void GraphStorageServiceAsyncClient::sync_updateVertex(apache::thrift::RpcOptions& rpcOptions, ::nebula::storage::cpp2::UpdateResponse& _return, const ::nebula::storage::cpp2::UpdateVertexRequest& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = updateVertexCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + updateVertexImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_updateVertex(_return, returnState); + }); +} + + +folly::Future< ::nebula::storage::cpp2::UpdateResponse> GraphStorageServiceAsyncClient::future_updateVertex(const ::nebula::storage::cpp2::UpdateVertexRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_updateVertex(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::storage::cpp2::UpdateResponse> GraphStorageServiceAsyncClient::semifuture_updateVertex(const ::nebula::storage::cpp2::UpdateVertexRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_updateVertex(rpcOptions, p_req); +} + +folly::Future< ::nebula::storage::cpp2::UpdateResponse> GraphStorageServiceAsyncClient::future_updateVertex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::UpdateVertexRequest& p_req) { + folly::Promise< ::nebula::storage::cpp2::UpdateResponse> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_updateVertex, channel_); + updateVertex(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::storage::cpp2::UpdateResponse> GraphStorageServiceAsyncClient::semifuture_updateVertex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::UpdateVertexRequest& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_updateVertex, channel_); + auto callback = std::move(callbackAndFuture.first); + updateVertex(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> GraphStorageServiceAsyncClient::header_future_updateVertex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::UpdateVertexRequest& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_updateVertex, channel_); + updateVertex(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> GraphStorageServiceAsyncClient::header_semifuture_updateVertex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::UpdateVertexRequest& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_updateVertex, channel_); + auto callback = std::move(callbackAndFuture.first); + updateVertex(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void GraphStorageServiceAsyncClient::updateVertex(folly::Function callback, const ::nebula::storage::cpp2::UpdateVertexRequest& p_req) { + updateVertex(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper GraphStorageServiceAsyncClient::recv_wrapped_updateVertex( ::nebula::storage::cpp2::UpdateResponse& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = GraphStorageService_updateVertex_presult; + constexpr auto const fname = "updateVertex"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void GraphStorageServiceAsyncClient::recv_updateVertex( ::nebula::storage::cpp2::UpdateResponse& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_updateVertex(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void GraphStorageServiceAsyncClient::recv_instance_updateVertex( ::nebula::storage::cpp2::UpdateResponse& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_updateVertex(_return, state); +} + +folly::exception_wrapper GraphStorageServiceAsyncClient::recv_instance_wrapped_updateVertex( ::nebula::storage::cpp2::UpdateResponse& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_updateVertex(_return, state); +} + +void GraphStorageServiceAsyncClient::updateEdge(std::unique_ptr callback, const ::nebula::storage::cpp2::UpdateEdgeRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + updateEdge(rpcOptions, std::move(callback), p_req); +} + +void GraphStorageServiceAsyncClient::updateEdge(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::storage::cpp2::UpdateEdgeRequest& p_req) { + auto ctx = updateEdgeCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + updateEdgeImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void GraphStorageServiceAsyncClient::updateEdgeImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::UpdateEdgeRequest& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + updateEdgeT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + updateEdgeT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> GraphStorageServiceAsyncClient::updateEdgeCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "GraphStorageService.updateEdge"); +} + +void GraphStorageServiceAsyncClient::sync_updateEdge( ::nebula::storage::cpp2::UpdateResponse& _return, const ::nebula::storage::cpp2::UpdateEdgeRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_updateEdge(rpcOptions, _return, p_req); +} + +void GraphStorageServiceAsyncClient::sync_updateEdge(apache::thrift::RpcOptions& rpcOptions, ::nebula::storage::cpp2::UpdateResponse& _return, const ::nebula::storage::cpp2::UpdateEdgeRequest& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = updateEdgeCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + updateEdgeImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_updateEdge(_return, returnState); + }); +} + + +folly::Future< ::nebula::storage::cpp2::UpdateResponse> GraphStorageServiceAsyncClient::future_updateEdge(const ::nebula::storage::cpp2::UpdateEdgeRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_updateEdge(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::storage::cpp2::UpdateResponse> GraphStorageServiceAsyncClient::semifuture_updateEdge(const ::nebula::storage::cpp2::UpdateEdgeRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_updateEdge(rpcOptions, p_req); +} + +folly::Future< ::nebula::storage::cpp2::UpdateResponse> GraphStorageServiceAsyncClient::future_updateEdge(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::UpdateEdgeRequest& p_req) { + folly::Promise< ::nebula::storage::cpp2::UpdateResponse> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_updateEdge, channel_); + updateEdge(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::storage::cpp2::UpdateResponse> GraphStorageServiceAsyncClient::semifuture_updateEdge(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::UpdateEdgeRequest& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_updateEdge, channel_); + auto callback = std::move(callbackAndFuture.first); + updateEdge(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> GraphStorageServiceAsyncClient::header_future_updateEdge(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::UpdateEdgeRequest& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_updateEdge, channel_); + updateEdge(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> GraphStorageServiceAsyncClient::header_semifuture_updateEdge(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::UpdateEdgeRequest& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_updateEdge, channel_); + auto callback = std::move(callbackAndFuture.first); + updateEdge(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void GraphStorageServiceAsyncClient::updateEdge(folly::Function callback, const ::nebula::storage::cpp2::UpdateEdgeRequest& p_req) { + updateEdge(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper GraphStorageServiceAsyncClient::recv_wrapped_updateEdge( ::nebula::storage::cpp2::UpdateResponse& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = GraphStorageService_updateEdge_presult; + constexpr auto const fname = "updateEdge"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void GraphStorageServiceAsyncClient::recv_updateEdge( ::nebula::storage::cpp2::UpdateResponse& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_updateEdge(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void GraphStorageServiceAsyncClient::recv_instance_updateEdge( ::nebula::storage::cpp2::UpdateResponse& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_updateEdge(_return, state); +} + +folly::exception_wrapper GraphStorageServiceAsyncClient::recv_instance_wrapped_updateEdge( ::nebula::storage::cpp2::UpdateResponse& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_updateEdge(_return, state); +} + +void GraphStorageServiceAsyncClient::scanVertex(std::unique_ptr callback, const ::nebula::storage::cpp2::ScanVertexRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + scanVertex(rpcOptions, std::move(callback), p_req); +} + +void GraphStorageServiceAsyncClient::scanVertex(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::storage::cpp2::ScanVertexRequest& p_req) { + auto ctx = scanVertexCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + scanVertexImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void GraphStorageServiceAsyncClient::scanVertexImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::ScanVertexRequest& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + scanVertexT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + scanVertexT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> GraphStorageServiceAsyncClient::scanVertexCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "GraphStorageService.scanVertex"); +} + +void GraphStorageServiceAsyncClient::sync_scanVertex( ::nebula::storage::cpp2::ScanVertexResponse& _return, const ::nebula::storage::cpp2::ScanVertexRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_scanVertex(rpcOptions, _return, p_req); +} + +void GraphStorageServiceAsyncClient::sync_scanVertex(apache::thrift::RpcOptions& rpcOptions, ::nebula::storage::cpp2::ScanVertexResponse& _return, const ::nebula::storage::cpp2::ScanVertexRequest& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = scanVertexCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + scanVertexImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_scanVertex(_return, returnState); + }); +} + + +folly::Future< ::nebula::storage::cpp2::ScanVertexResponse> GraphStorageServiceAsyncClient::future_scanVertex(const ::nebula::storage::cpp2::ScanVertexRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_scanVertex(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::storage::cpp2::ScanVertexResponse> GraphStorageServiceAsyncClient::semifuture_scanVertex(const ::nebula::storage::cpp2::ScanVertexRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_scanVertex(rpcOptions, p_req); +} + +folly::Future< ::nebula::storage::cpp2::ScanVertexResponse> GraphStorageServiceAsyncClient::future_scanVertex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::ScanVertexRequest& p_req) { + folly::Promise< ::nebula::storage::cpp2::ScanVertexResponse> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_scanVertex, channel_); + scanVertex(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::storage::cpp2::ScanVertexResponse> GraphStorageServiceAsyncClient::semifuture_scanVertex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::ScanVertexRequest& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_scanVertex, channel_); + auto callback = std::move(callbackAndFuture.first); + scanVertex(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> GraphStorageServiceAsyncClient::header_future_scanVertex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::ScanVertexRequest& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_scanVertex, channel_); + scanVertex(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> GraphStorageServiceAsyncClient::header_semifuture_scanVertex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::ScanVertexRequest& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_scanVertex, channel_); + auto callback = std::move(callbackAndFuture.first); + scanVertex(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void GraphStorageServiceAsyncClient::scanVertex(folly::Function callback, const ::nebula::storage::cpp2::ScanVertexRequest& p_req) { + scanVertex(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper GraphStorageServiceAsyncClient::recv_wrapped_scanVertex( ::nebula::storage::cpp2::ScanVertexResponse& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = GraphStorageService_scanVertex_presult; + constexpr auto const fname = "scanVertex"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void GraphStorageServiceAsyncClient::recv_scanVertex( ::nebula::storage::cpp2::ScanVertexResponse& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_scanVertex(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void GraphStorageServiceAsyncClient::recv_instance_scanVertex( ::nebula::storage::cpp2::ScanVertexResponse& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_scanVertex(_return, state); +} + +folly::exception_wrapper GraphStorageServiceAsyncClient::recv_instance_wrapped_scanVertex( ::nebula::storage::cpp2::ScanVertexResponse& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_scanVertex(_return, state); +} + +void GraphStorageServiceAsyncClient::scanEdge(std::unique_ptr callback, const ::nebula::storage::cpp2::ScanEdgeRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + scanEdge(rpcOptions, std::move(callback), p_req); +} + +void GraphStorageServiceAsyncClient::scanEdge(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::storage::cpp2::ScanEdgeRequest& p_req) { + auto ctx = scanEdgeCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + scanEdgeImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void GraphStorageServiceAsyncClient::scanEdgeImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::ScanEdgeRequest& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + scanEdgeT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + scanEdgeT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> GraphStorageServiceAsyncClient::scanEdgeCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "GraphStorageService.scanEdge"); +} + +void GraphStorageServiceAsyncClient::sync_scanEdge( ::nebula::storage::cpp2::ScanEdgeResponse& _return, const ::nebula::storage::cpp2::ScanEdgeRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_scanEdge(rpcOptions, _return, p_req); +} + +void GraphStorageServiceAsyncClient::sync_scanEdge(apache::thrift::RpcOptions& rpcOptions, ::nebula::storage::cpp2::ScanEdgeResponse& _return, const ::nebula::storage::cpp2::ScanEdgeRequest& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = scanEdgeCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + scanEdgeImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_scanEdge(_return, returnState); + }); +} + + +folly::Future< ::nebula::storage::cpp2::ScanEdgeResponse> GraphStorageServiceAsyncClient::future_scanEdge(const ::nebula::storage::cpp2::ScanEdgeRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_scanEdge(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::storage::cpp2::ScanEdgeResponse> GraphStorageServiceAsyncClient::semifuture_scanEdge(const ::nebula::storage::cpp2::ScanEdgeRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_scanEdge(rpcOptions, p_req); +} + +folly::Future< ::nebula::storage::cpp2::ScanEdgeResponse> GraphStorageServiceAsyncClient::future_scanEdge(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::ScanEdgeRequest& p_req) { + folly::Promise< ::nebula::storage::cpp2::ScanEdgeResponse> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_scanEdge, channel_); + scanEdge(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::storage::cpp2::ScanEdgeResponse> GraphStorageServiceAsyncClient::semifuture_scanEdge(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::ScanEdgeRequest& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_scanEdge, channel_); + auto callback = std::move(callbackAndFuture.first); + scanEdge(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> GraphStorageServiceAsyncClient::header_future_scanEdge(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::ScanEdgeRequest& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_scanEdge, channel_); + scanEdge(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> GraphStorageServiceAsyncClient::header_semifuture_scanEdge(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::ScanEdgeRequest& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_scanEdge, channel_); + auto callback = std::move(callbackAndFuture.first); + scanEdge(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void GraphStorageServiceAsyncClient::scanEdge(folly::Function callback, const ::nebula::storage::cpp2::ScanEdgeRequest& p_req) { + scanEdge(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper GraphStorageServiceAsyncClient::recv_wrapped_scanEdge( ::nebula::storage::cpp2::ScanEdgeResponse& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = GraphStorageService_scanEdge_presult; + constexpr auto const fname = "scanEdge"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void GraphStorageServiceAsyncClient::recv_scanEdge( ::nebula::storage::cpp2::ScanEdgeResponse& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_scanEdge(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void GraphStorageServiceAsyncClient::recv_instance_scanEdge( ::nebula::storage::cpp2::ScanEdgeResponse& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_scanEdge(_return, state); +} + +folly::exception_wrapper GraphStorageServiceAsyncClient::recv_instance_wrapped_scanEdge( ::nebula::storage::cpp2::ScanEdgeResponse& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_scanEdge(_return, state); +} + +void GraphStorageServiceAsyncClient::getUUID(std::unique_ptr callback, const ::nebula::storage::cpp2::GetUUIDReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + getUUID(rpcOptions, std::move(callback), p_req); +} + +void GraphStorageServiceAsyncClient::getUUID(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::storage::cpp2::GetUUIDReq& p_req) { + auto ctx = getUUIDCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + getUUIDImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void GraphStorageServiceAsyncClient::getUUIDImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::GetUUIDReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + getUUIDT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + getUUIDT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> GraphStorageServiceAsyncClient::getUUIDCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "GraphStorageService.getUUID"); +} + +void GraphStorageServiceAsyncClient::sync_getUUID( ::nebula::storage::cpp2::GetUUIDResp& _return, const ::nebula::storage::cpp2::GetUUIDReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_getUUID(rpcOptions, _return, p_req); +} + +void GraphStorageServiceAsyncClient::sync_getUUID(apache::thrift::RpcOptions& rpcOptions, ::nebula::storage::cpp2::GetUUIDResp& _return, const ::nebula::storage::cpp2::GetUUIDReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = getUUIDCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + getUUIDImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_getUUID(_return, returnState); + }); +} + + +folly::Future< ::nebula::storage::cpp2::GetUUIDResp> GraphStorageServiceAsyncClient::future_getUUID(const ::nebula::storage::cpp2::GetUUIDReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_getUUID(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::storage::cpp2::GetUUIDResp> GraphStorageServiceAsyncClient::semifuture_getUUID(const ::nebula::storage::cpp2::GetUUIDReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_getUUID(rpcOptions, p_req); +} + +folly::Future< ::nebula::storage::cpp2::GetUUIDResp> GraphStorageServiceAsyncClient::future_getUUID(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::GetUUIDReq& p_req) { + folly::Promise< ::nebula::storage::cpp2::GetUUIDResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_getUUID, channel_); + getUUID(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::storage::cpp2::GetUUIDResp> GraphStorageServiceAsyncClient::semifuture_getUUID(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::GetUUIDReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_getUUID, channel_); + auto callback = std::move(callbackAndFuture.first); + getUUID(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> GraphStorageServiceAsyncClient::header_future_getUUID(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::GetUUIDReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_getUUID, channel_); + getUUID(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> GraphStorageServiceAsyncClient::header_semifuture_getUUID(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::GetUUIDReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_getUUID, channel_); + auto callback = std::move(callbackAndFuture.first); + getUUID(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void GraphStorageServiceAsyncClient::getUUID(folly::Function callback, const ::nebula::storage::cpp2::GetUUIDReq& p_req) { + getUUID(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper GraphStorageServiceAsyncClient::recv_wrapped_getUUID( ::nebula::storage::cpp2::GetUUIDResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = GraphStorageService_getUUID_presult; + constexpr auto const fname = "getUUID"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void GraphStorageServiceAsyncClient::recv_getUUID( ::nebula::storage::cpp2::GetUUIDResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_getUUID(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void GraphStorageServiceAsyncClient::recv_instance_getUUID( ::nebula::storage::cpp2::GetUUIDResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_getUUID(_return, state); +} + +folly::exception_wrapper GraphStorageServiceAsyncClient::recv_instance_wrapped_getUUID( ::nebula::storage::cpp2::GetUUIDResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_getUUID(_return, state); +} + +void GraphStorageServiceAsyncClient::lookupIndex(std::unique_ptr callback, const ::nebula::storage::cpp2::LookupIndexRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + lookupIndex(rpcOptions, std::move(callback), p_req); +} + +void GraphStorageServiceAsyncClient::lookupIndex(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::storage::cpp2::LookupIndexRequest& p_req) { + auto ctx = lookupIndexCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + lookupIndexImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void GraphStorageServiceAsyncClient::lookupIndexImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::LookupIndexRequest& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + lookupIndexT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + lookupIndexT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> GraphStorageServiceAsyncClient::lookupIndexCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "GraphStorageService.lookupIndex"); +} + +void GraphStorageServiceAsyncClient::sync_lookupIndex( ::nebula::storage::cpp2::LookupIndexResp& _return, const ::nebula::storage::cpp2::LookupIndexRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_lookupIndex(rpcOptions, _return, p_req); +} + +void GraphStorageServiceAsyncClient::sync_lookupIndex(apache::thrift::RpcOptions& rpcOptions, ::nebula::storage::cpp2::LookupIndexResp& _return, const ::nebula::storage::cpp2::LookupIndexRequest& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = lookupIndexCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + lookupIndexImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_lookupIndex(_return, returnState); + }); +} + + +folly::Future< ::nebula::storage::cpp2::LookupIndexResp> GraphStorageServiceAsyncClient::future_lookupIndex(const ::nebula::storage::cpp2::LookupIndexRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_lookupIndex(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::storage::cpp2::LookupIndexResp> GraphStorageServiceAsyncClient::semifuture_lookupIndex(const ::nebula::storage::cpp2::LookupIndexRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_lookupIndex(rpcOptions, p_req); +} + +folly::Future< ::nebula::storage::cpp2::LookupIndexResp> GraphStorageServiceAsyncClient::future_lookupIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::LookupIndexRequest& p_req) { + folly::Promise< ::nebula::storage::cpp2::LookupIndexResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_lookupIndex, channel_); + lookupIndex(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::storage::cpp2::LookupIndexResp> GraphStorageServiceAsyncClient::semifuture_lookupIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::LookupIndexRequest& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_lookupIndex, channel_); + auto callback = std::move(callbackAndFuture.first); + lookupIndex(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> GraphStorageServiceAsyncClient::header_future_lookupIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::LookupIndexRequest& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_lookupIndex, channel_); + lookupIndex(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> GraphStorageServiceAsyncClient::header_semifuture_lookupIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::LookupIndexRequest& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_lookupIndex, channel_); + auto callback = std::move(callbackAndFuture.first); + lookupIndex(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void GraphStorageServiceAsyncClient::lookupIndex(folly::Function callback, const ::nebula::storage::cpp2::LookupIndexRequest& p_req) { + lookupIndex(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper GraphStorageServiceAsyncClient::recv_wrapped_lookupIndex( ::nebula::storage::cpp2::LookupIndexResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = GraphStorageService_lookupIndex_presult; + constexpr auto const fname = "lookupIndex"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void GraphStorageServiceAsyncClient::recv_lookupIndex( ::nebula::storage::cpp2::LookupIndexResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_lookupIndex(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void GraphStorageServiceAsyncClient::recv_instance_lookupIndex( ::nebula::storage::cpp2::LookupIndexResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_lookupIndex(_return, state); +} + +folly::exception_wrapper GraphStorageServiceAsyncClient::recv_instance_wrapped_lookupIndex( ::nebula::storage::cpp2::LookupIndexResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_lookupIndex(_return, state); +} + +void GraphStorageServiceAsyncClient::lookupAndTraverse(std::unique_ptr callback, const ::nebula::storage::cpp2::LookupAndTraverseRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + lookupAndTraverse(rpcOptions, std::move(callback), p_req); +} + +void GraphStorageServiceAsyncClient::lookupAndTraverse(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::storage::cpp2::LookupAndTraverseRequest& p_req) { + auto ctx = lookupAndTraverseCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + lookupAndTraverseImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void GraphStorageServiceAsyncClient::lookupAndTraverseImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::LookupAndTraverseRequest& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + lookupAndTraverseT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + lookupAndTraverseT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> GraphStorageServiceAsyncClient::lookupAndTraverseCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "GraphStorageService.lookupAndTraverse"); +} + +void GraphStorageServiceAsyncClient::sync_lookupAndTraverse( ::nebula::storage::cpp2::GetNeighborsResponse& _return, const ::nebula::storage::cpp2::LookupAndTraverseRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_lookupAndTraverse(rpcOptions, _return, p_req); +} + +void GraphStorageServiceAsyncClient::sync_lookupAndTraverse(apache::thrift::RpcOptions& rpcOptions, ::nebula::storage::cpp2::GetNeighborsResponse& _return, const ::nebula::storage::cpp2::LookupAndTraverseRequest& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = lookupAndTraverseCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + lookupAndTraverseImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_lookupAndTraverse(_return, returnState); + }); +} + + +folly::Future< ::nebula::storage::cpp2::GetNeighborsResponse> GraphStorageServiceAsyncClient::future_lookupAndTraverse(const ::nebula::storage::cpp2::LookupAndTraverseRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_lookupAndTraverse(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::storage::cpp2::GetNeighborsResponse> GraphStorageServiceAsyncClient::semifuture_lookupAndTraverse(const ::nebula::storage::cpp2::LookupAndTraverseRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_lookupAndTraverse(rpcOptions, p_req); +} + +folly::Future< ::nebula::storage::cpp2::GetNeighborsResponse> GraphStorageServiceAsyncClient::future_lookupAndTraverse(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::LookupAndTraverseRequest& p_req) { + folly::Promise< ::nebula::storage::cpp2::GetNeighborsResponse> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_lookupAndTraverse, channel_); + lookupAndTraverse(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::storage::cpp2::GetNeighborsResponse> GraphStorageServiceAsyncClient::semifuture_lookupAndTraverse(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::LookupAndTraverseRequest& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_lookupAndTraverse, channel_); + auto callback = std::move(callbackAndFuture.first); + lookupAndTraverse(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> GraphStorageServiceAsyncClient::header_future_lookupAndTraverse(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::LookupAndTraverseRequest& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_lookupAndTraverse, channel_); + lookupAndTraverse(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> GraphStorageServiceAsyncClient::header_semifuture_lookupAndTraverse(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::LookupAndTraverseRequest& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_lookupAndTraverse, channel_); + auto callback = std::move(callbackAndFuture.first); + lookupAndTraverse(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void GraphStorageServiceAsyncClient::lookupAndTraverse(folly::Function callback, const ::nebula::storage::cpp2::LookupAndTraverseRequest& p_req) { + lookupAndTraverse(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper GraphStorageServiceAsyncClient::recv_wrapped_lookupAndTraverse( ::nebula::storage::cpp2::GetNeighborsResponse& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = GraphStorageService_lookupAndTraverse_presult; + constexpr auto const fname = "lookupAndTraverse"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void GraphStorageServiceAsyncClient::recv_lookupAndTraverse( ::nebula::storage::cpp2::GetNeighborsResponse& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_lookupAndTraverse(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void GraphStorageServiceAsyncClient::recv_instance_lookupAndTraverse( ::nebula::storage::cpp2::GetNeighborsResponse& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_lookupAndTraverse(_return, state); +} + +folly::exception_wrapper GraphStorageServiceAsyncClient::recv_instance_wrapped_lookupAndTraverse( ::nebula::storage::cpp2::GetNeighborsResponse& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_lookupAndTraverse(_return, state); +} + +void GraphStorageServiceAsyncClient::chainUpdateEdge(std::unique_ptr callback, const ::nebula::storage::cpp2::UpdateEdgeRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + chainUpdateEdge(rpcOptions, std::move(callback), p_req); +} + +void GraphStorageServiceAsyncClient::chainUpdateEdge(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::storage::cpp2::UpdateEdgeRequest& p_req) { + auto ctx = chainUpdateEdgeCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + chainUpdateEdgeImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void GraphStorageServiceAsyncClient::chainUpdateEdgeImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::UpdateEdgeRequest& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + chainUpdateEdgeT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + chainUpdateEdgeT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> GraphStorageServiceAsyncClient::chainUpdateEdgeCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "GraphStorageService.chainUpdateEdge"); +} + +void GraphStorageServiceAsyncClient::sync_chainUpdateEdge( ::nebula::storage::cpp2::UpdateResponse& _return, const ::nebula::storage::cpp2::UpdateEdgeRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_chainUpdateEdge(rpcOptions, _return, p_req); +} + +void GraphStorageServiceAsyncClient::sync_chainUpdateEdge(apache::thrift::RpcOptions& rpcOptions, ::nebula::storage::cpp2::UpdateResponse& _return, const ::nebula::storage::cpp2::UpdateEdgeRequest& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = chainUpdateEdgeCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + chainUpdateEdgeImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_chainUpdateEdge(_return, returnState); + }); +} + + +folly::Future< ::nebula::storage::cpp2::UpdateResponse> GraphStorageServiceAsyncClient::future_chainUpdateEdge(const ::nebula::storage::cpp2::UpdateEdgeRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_chainUpdateEdge(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::storage::cpp2::UpdateResponse> GraphStorageServiceAsyncClient::semifuture_chainUpdateEdge(const ::nebula::storage::cpp2::UpdateEdgeRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_chainUpdateEdge(rpcOptions, p_req); +} + +folly::Future< ::nebula::storage::cpp2::UpdateResponse> GraphStorageServiceAsyncClient::future_chainUpdateEdge(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::UpdateEdgeRequest& p_req) { + folly::Promise< ::nebula::storage::cpp2::UpdateResponse> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_chainUpdateEdge, channel_); + chainUpdateEdge(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::storage::cpp2::UpdateResponse> GraphStorageServiceAsyncClient::semifuture_chainUpdateEdge(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::UpdateEdgeRequest& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_chainUpdateEdge, channel_); + auto callback = std::move(callbackAndFuture.first); + chainUpdateEdge(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> GraphStorageServiceAsyncClient::header_future_chainUpdateEdge(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::UpdateEdgeRequest& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_chainUpdateEdge, channel_); + chainUpdateEdge(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> GraphStorageServiceAsyncClient::header_semifuture_chainUpdateEdge(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::UpdateEdgeRequest& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_chainUpdateEdge, channel_); + auto callback = std::move(callbackAndFuture.first); + chainUpdateEdge(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void GraphStorageServiceAsyncClient::chainUpdateEdge(folly::Function callback, const ::nebula::storage::cpp2::UpdateEdgeRequest& p_req) { + chainUpdateEdge(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper GraphStorageServiceAsyncClient::recv_wrapped_chainUpdateEdge( ::nebula::storage::cpp2::UpdateResponse& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = GraphStorageService_chainUpdateEdge_presult; + constexpr auto const fname = "chainUpdateEdge"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void GraphStorageServiceAsyncClient::recv_chainUpdateEdge( ::nebula::storage::cpp2::UpdateResponse& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_chainUpdateEdge(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void GraphStorageServiceAsyncClient::recv_instance_chainUpdateEdge( ::nebula::storage::cpp2::UpdateResponse& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_chainUpdateEdge(_return, state); +} + +folly::exception_wrapper GraphStorageServiceAsyncClient::recv_instance_wrapped_chainUpdateEdge( ::nebula::storage::cpp2::UpdateResponse& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_chainUpdateEdge(_return, state); +} + +void GraphStorageServiceAsyncClient::chainAddEdges(std::unique_ptr callback, const ::nebula::storage::cpp2::AddEdgesRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + chainAddEdges(rpcOptions, std::move(callback), p_req); +} + +void GraphStorageServiceAsyncClient::chainAddEdges(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::storage::cpp2::AddEdgesRequest& p_req) { + auto ctx = chainAddEdgesCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + chainAddEdgesImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void GraphStorageServiceAsyncClient::chainAddEdgesImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::AddEdgesRequest& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + chainAddEdgesT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + chainAddEdgesT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> GraphStorageServiceAsyncClient::chainAddEdgesCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "GraphStorageService.chainAddEdges"); +} + +void GraphStorageServiceAsyncClient::sync_chainAddEdges( ::nebula::storage::cpp2::ExecResponse& _return, const ::nebula::storage::cpp2::AddEdgesRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_chainAddEdges(rpcOptions, _return, p_req); +} + +void GraphStorageServiceAsyncClient::sync_chainAddEdges(apache::thrift::RpcOptions& rpcOptions, ::nebula::storage::cpp2::ExecResponse& _return, const ::nebula::storage::cpp2::AddEdgesRequest& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = chainAddEdgesCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + chainAddEdgesImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_chainAddEdges(_return, returnState); + }); +} + + +folly::Future< ::nebula::storage::cpp2::ExecResponse> GraphStorageServiceAsyncClient::future_chainAddEdges(const ::nebula::storage::cpp2::AddEdgesRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_chainAddEdges(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::storage::cpp2::ExecResponse> GraphStorageServiceAsyncClient::semifuture_chainAddEdges(const ::nebula::storage::cpp2::AddEdgesRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_chainAddEdges(rpcOptions, p_req); +} + +folly::Future< ::nebula::storage::cpp2::ExecResponse> GraphStorageServiceAsyncClient::future_chainAddEdges(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::AddEdgesRequest& p_req) { + folly::Promise< ::nebula::storage::cpp2::ExecResponse> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_chainAddEdges, channel_); + chainAddEdges(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::storage::cpp2::ExecResponse> GraphStorageServiceAsyncClient::semifuture_chainAddEdges(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::AddEdgesRequest& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_chainAddEdges, channel_); + auto callback = std::move(callbackAndFuture.first); + chainAddEdges(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> GraphStorageServiceAsyncClient::header_future_chainAddEdges(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::AddEdgesRequest& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_chainAddEdges, channel_); + chainAddEdges(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> GraphStorageServiceAsyncClient::header_semifuture_chainAddEdges(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::AddEdgesRequest& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_chainAddEdges, channel_); + auto callback = std::move(callbackAndFuture.first); + chainAddEdges(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void GraphStorageServiceAsyncClient::chainAddEdges(folly::Function callback, const ::nebula::storage::cpp2::AddEdgesRequest& p_req) { + chainAddEdges(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper GraphStorageServiceAsyncClient::recv_wrapped_chainAddEdges( ::nebula::storage::cpp2::ExecResponse& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = GraphStorageService_chainAddEdges_presult; + constexpr auto const fname = "chainAddEdges"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void GraphStorageServiceAsyncClient::recv_chainAddEdges( ::nebula::storage::cpp2::ExecResponse& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_chainAddEdges(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void GraphStorageServiceAsyncClient::recv_instance_chainAddEdges( ::nebula::storage::cpp2::ExecResponse& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_chainAddEdges(_return, state); +} + +folly::exception_wrapper GraphStorageServiceAsyncClient::recv_instance_wrapped_chainAddEdges( ::nebula::storage::cpp2::ExecResponse& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_chainAddEdges(_return, state); +} + + +}}} // nebula::storage::cpp2 diff --git a/src/interface/gen-cpp2/GraphStorageServiceAsyncClient.h b/src/interface/gen-cpp2/GraphStorageServiceAsyncClient.h new file mode 100644 index 00000000..36e379a1 --- /dev/null +++ b/src/interface/gen-cpp2/GraphStorageServiceAsyncClient.h @@ -0,0 +1,1346 @@ +/** + * Autogenerated by Thrift for storage.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#pragma once + +#include + +#include "storage_types.h" +#include "common_types.h" +#include "meta_types.h" + +namespace apache { namespace thrift { + class Cpp2RequestContext; + namespace detail { namespace ac { struct ClientRequestContext; }} + namespace transport { class THeader; } +}} + +namespace nebula { namespace storage { namespace cpp2 { + +class GraphStorageServiceAsyncClient : public apache::thrift::GeneratedAsyncClient { + public: + using apache::thrift::GeneratedAsyncClient::GeneratedAsyncClient; + + char const* getServiceName() const noexcept override { + return "GraphStorageService"; + } + + + virtual void getNeighbors(std::unique_ptr callback, const ::nebula::storage::cpp2::GetNeighborsRequest& p_req); + virtual void getNeighbors(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::storage::cpp2::GetNeighborsRequest& p_req); + protected: + void getNeighborsImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::GetNeighborsRequest& p_req); + public: + + virtual void sync_getNeighbors( ::nebula::storage::cpp2::GetNeighborsResponse& _return, const ::nebula::storage::cpp2::GetNeighborsRequest& p_req); + virtual void sync_getNeighbors(apache::thrift::RpcOptions& rpcOptions, ::nebula::storage::cpp2::GetNeighborsResponse& _return, const ::nebula::storage::cpp2::GetNeighborsRequest& p_req); + + virtual folly::Future< ::nebula::storage::cpp2::GetNeighborsResponse> future_getNeighbors(const ::nebula::storage::cpp2::GetNeighborsRequest& p_req); + virtual folly::SemiFuture< ::nebula::storage::cpp2::GetNeighborsResponse> semifuture_getNeighbors(const ::nebula::storage::cpp2::GetNeighborsRequest& p_req); + virtual folly::Future< ::nebula::storage::cpp2::GetNeighborsResponse> future_getNeighbors(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::GetNeighborsRequest& p_req); + virtual folly::SemiFuture< ::nebula::storage::cpp2::GetNeighborsResponse> semifuture_getNeighbors(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::GetNeighborsRequest& p_req); + virtual folly::Future>> header_future_getNeighbors(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::GetNeighborsRequest& p_req); + virtual folly::SemiFuture>> header_semifuture_getNeighbors(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::GetNeighborsRequest& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::storage::cpp2::GetNeighborsResponse> co_getNeighbors(const ::nebula::storage::cpp2::GetNeighborsRequest& p_req) { + return co_getNeighbors(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::storage::cpp2::GetNeighborsResponse> co_getNeighbors(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::GetNeighborsRequest& p_req) { + return co_getNeighbors(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::storage::cpp2::GetNeighborsResponse> co_getNeighbors(apache::thrift::RpcOptions* rpcOptions, const ::nebula::storage::cpp2::GetNeighborsRequest& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = getNeighborsCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + getNeighborsImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + getNeighborsImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::storage::cpp2::GetNeighborsResponse _return; + if (auto ew = recv_wrapped_getNeighbors(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void getNeighbors(folly::Function callback, const ::nebula::storage::cpp2::GetNeighborsRequest& p_req); + + + static folly::exception_wrapper recv_wrapped_getNeighbors( ::nebula::storage::cpp2::GetNeighborsResponse& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_getNeighbors( ::nebula::storage::cpp2::GetNeighborsResponse& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_getNeighbors( ::nebula::storage::cpp2::GetNeighborsResponse& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_getNeighbors( ::nebula::storage::cpp2::GetNeighborsResponse& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void getNeighborsT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::GetNeighborsRequest& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> getNeighborsCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void getProps(std::unique_ptr callback, const ::nebula::storage::cpp2::GetPropRequest& p_req); + virtual void getProps(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::storage::cpp2::GetPropRequest& p_req); + protected: + void getPropsImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::GetPropRequest& p_req); + public: + + virtual void sync_getProps( ::nebula::storage::cpp2::GetPropResponse& _return, const ::nebula::storage::cpp2::GetPropRequest& p_req); + virtual void sync_getProps(apache::thrift::RpcOptions& rpcOptions, ::nebula::storage::cpp2::GetPropResponse& _return, const ::nebula::storage::cpp2::GetPropRequest& p_req); + + virtual folly::Future< ::nebula::storage::cpp2::GetPropResponse> future_getProps(const ::nebula::storage::cpp2::GetPropRequest& p_req); + virtual folly::SemiFuture< ::nebula::storage::cpp2::GetPropResponse> semifuture_getProps(const ::nebula::storage::cpp2::GetPropRequest& p_req); + virtual folly::Future< ::nebula::storage::cpp2::GetPropResponse> future_getProps(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::GetPropRequest& p_req); + virtual folly::SemiFuture< ::nebula::storage::cpp2::GetPropResponse> semifuture_getProps(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::GetPropRequest& p_req); + virtual folly::Future>> header_future_getProps(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::GetPropRequest& p_req); + virtual folly::SemiFuture>> header_semifuture_getProps(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::GetPropRequest& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::storage::cpp2::GetPropResponse> co_getProps(const ::nebula::storage::cpp2::GetPropRequest& p_req) { + return co_getProps(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::storage::cpp2::GetPropResponse> co_getProps(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::GetPropRequest& p_req) { + return co_getProps(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::storage::cpp2::GetPropResponse> co_getProps(apache::thrift::RpcOptions* rpcOptions, const ::nebula::storage::cpp2::GetPropRequest& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = getPropsCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + getPropsImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + getPropsImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::storage::cpp2::GetPropResponse _return; + if (auto ew = recv_wrapped_getProps(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void getProps(folly::Function callback, const ::nebula::storage::cpp2::GetPropRequest& p_req); + + + static folly::exception_wrapper recv_wrapped_getProps( ::nebula::storage::cpp2::GetPropResponse& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_getProps( ::nebula::storage::cpp2::GetPropResponse& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_getProps( ::nebula::storage::cpp2::GetPropResponse& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_getProps( ::nebula::storage::cpp2::GetPropResponse& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void getPropsT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::GetPropRequest& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> getPropsCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void addVertices(std::unique_ptr callback, const ::nebula::storage::cpp2::AddVerticesRequest& p_req); + virtual void addVertices(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::storage::cpp2::AddVerticesRequest& p_req); + protected: + void addVerticesImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::AddVerticesRequest& p_req); + public: + + virtual void sync_addVertices( ::nebula::storage::cpp2::ExecResponse& _return, const ::nebula::storage::cpp2::AddVerticesRequest& p_req); + virtual void sync_addVertices(apache::thrift::RpcOptions& rpcOptions, ::nebula::storage::cpp2::ExecResponse& _return, const ::nebula::storage::cpp2::AddVerticesRequest& p_req); + + virtual folly::Future< ::nebula::storage::cpp2::ExecResponse> future_addVertices(const ::nebula::storage::cpp2::AddVerticesRequest& p_req); + virtual folly::SemiFuture< ::nebula::storage::cpp2::ExecResponse> semifuture_addVertices(const ::nebula::storage::cpp2::AddVerticesRequest& p_req); + virtual folly::Future< ::nebula::storage::cpp2::ExecResponse> future_addVertices(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::AddVerticesRequest& p_req); + virtual folly::SemiFuture< ::nebula::storage::cpp2::ExecResponse> semifuture_addVertices(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::AddVerticesRequest& p_req); + virtual folly::Future>> header_future_addVertices(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::AddVerticesRequest& p_req); + virtual folly::SemiFuture>> header_semifuture_addVertices(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::AddVerticesRequest& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::storage::cpp2::ExecResponse> co_addVertices(const ::nebula::storage::cpp2::AddVerticesRequest& p_req) { + return co_addVertices(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::storage::cpp2::ExecResponse> co_addVertices(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::AddVerticesRequest& p_req) { + return co_addVertices(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::storage::cpp2::ExecResponse> co_addVertices(apache::thrift::RpcOptions* rpcOptions, const ::nebula::storage::cpp2::AddVerticesRequest& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = addVerticesCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + addVerticesImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + addVerticesImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::storage::cpp2::ExecResponse _return; + if (auto ew = recv_wrapped_addVertices(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void addVertices(folly::Function callback, const ::nebula::storage::cpp2::AddVerticesRequest& p_req); + + + static folly::exception_wrapper recv_wrapped_addVertices( ::nebula::storage::cpp2::ExecResponse& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_addVertices( ::nebula::storage::cpp2::ExecResponse& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_addVertices( ::nebula::storage::cpp2::ExecResponse& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_addVertices( ::nebula::storage::cpp2::ExecResponse& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void addVerticesT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::AddVerticesRequest& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> addVerticesCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void addEdges(std::unique_ptr callback, const ::nebula::storage::cpp2::AddEdgesRequest& p_req); + virtual void addEdges(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::storage::cpp2::AddEdgesRequest& p_req); + protected: + void addEdgesImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::AddEdgesRequest& p_req); + public: + + virtual void sync_addEdges( ::nebula::storage::cpp2::ExecResponse& _return, const ::nebula::storage::cpp2::AddEdgesRequest& p_req); + virtual void sync_addEdges(apache::thrift::RpcOptions& rpcOptions, ::nebula::storage::cpp2::ExecResponse& _return, const ::nebula::storage::cpp2::AddEdgesRequest& p_req); + + virtual folly::Future< ::nebula::storage::cpp2::ExecResponse> future_addEdges(const ::nebula::storage::cpp2::AddEdgesRequest& p_req); + virtual folly::SemiFuture< ::nebula::storage::cpp2::ExecResponse> semifuture_addEdges(const ::nebula::storage::cpp2::AddEdgesRequest& p_req); + virtual folly::Future< ::nebula::storage::cpp2::ExecResponse> future_addEdges(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::AddEdgesRequest& p_req); + virtual folly::SemiFuture< ::nebula::storage::cpp2::ExecResponse> semifuture_addEdges(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::AddEdgesRequest& p_req); + virtual folly::Future>> header_future_addEdges(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::AddEdgesRequest& p_req); + virtual folly::SemiFuture>> header_semifuture_addEdges(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::AddEdgesRequest& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::storage::cpp2::ExecResponse> co_addEdges(const ::nebula::storage::cpp2::AddEdgesRequest& p_req) { + return co_addEdges(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::storage::cpp2::ExecResponse> co_addEdges(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::AddEdgesRequest& p_req) { + return co_addEdges(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::storage::cpp2::ExecResponse> co_addEdges(apache::thrift::RpcOptions* rpcOptions, const ::nebula::storage::cpp2::AddEdgesRequest& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = addEdgesCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + addEdgesImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + addEdgesImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::storage::cpp2::ExecResponse _return; + if (auto ew = recv_wrapped_addEdges(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void addEdges(folly::Function callback, const ::nebula::storage::cpp2::AddEdgesRequest& p_req); + + + static folly::exception_wrapper recv_wrapped_addEdges( ::nebula::storage::cpp2::ExecResponse& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_addEdges( ::nebula::storage::cpp2::ExecResponse& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_addEdges( ::nebula::storage::cpp2::ExecResponse& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_addEdges( ::nebula::storage::cpp2::ExecResponse& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void addEdgesT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::AddEdgesRequest& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> addEdgesCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void deleteEdges(std::unique_ptr callback, const ::nebula::storage::cpp2::DeleteEdgesRequest& p_req); + virtual void deleteEdges(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::storage::cpp2::DeleteEdgesRequest& p_req); + protected: + void deleteEdgesImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::DeleteEdgesRequest& p_req); + public: + + virtual void sync_deleteEdges( ::nebula::storage::cpp2::ExecResponse& _return, const ::nebula::storage::cpp2::DeleteEdgesRequest& p_req); + virtual void sync_deleteEdges(apache::thrift::RpcOptions& rpcOptions, ::nebula::storage::cpp2::ExecResponse& _return, const ::nebula::storage::cpp2::DeleteEdgesRequest& p_req); + + virtual folly::Future< ::nebula::storage::cpp2::ExecResponse> future_deleteEdges(const ::nebula::storage::cpp2::DeleteEdgesRequest& p_req); + virtual folly::SemiFuture< ::nebula::storage::cpp2::ExecResponse> semifuture_deleteEdges(const ::nebula::storage::cpp2::DeleteEdgesRequest& p_req); + virtual folly::Future< ::nebula::storage::cpp2::ExecResponse> future_deleteEdges(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::DeleteEdgesRequest& p_req); + virtual folly::SemiFuture< ::nebula::storage::cpp2::ExecResponse> semifuture_deleteEdges(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::DeleteEdgesRequest& p_req); + virtual folly::Future>> header_future_deleteEdges(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::DeleteEdgesRequest& p_req); + virtual folly::SemiFuture>> header_semifuture_deleteEdges(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::DeleteEdgesRequest& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::storage::cpp2::ExecResponse> co_deleteEdges(const ::nebula::storage::cpp2::DeleteEdgesRequest& p_req) { + return co_deleteEdges(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::storage::cpp2::ExecResponse> co_deleteEdges(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::DeleteEdgesRequest& p_req) { + return co_deleteEdges(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::storage::cpp2::ExecResponse> co_deleteEdges(apache::thrift::RpcOptions* rpcOptions, const ::nebula::storage::cpp2::DeleteEdgesRequest& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = deleteEdgesCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + deleteEdgesImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + deleteEdgesImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::storage::cpp2::ExecResponse _return; + if (auto ew = recv_wrapped_deleteEdges(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void deleteEdges(folly::Function callback, const ::nebula::storage::cpp2::DeleteEdgesRequest& p_req); + + + static folly::exception_wrapper recv_wrapped_deleteEdges( ::nebula::storage::cpp2::ExecResponse& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_deleteEdges( ::nebula::storage::cpp2::ExecResponse& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_deleteEdges( ::nebula::storage::cpp2::ExecResponse& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_deleteEdges( ::nebula::storage::cpp2::ExecResponse& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void deleteEdgesT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::DeleteEdgesRequest& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> deleteEdgesCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void deleteVertices(std::unique_ptr callback, const ::nebula::storage::cpp2::DeleteVerticesRequest& p_req); + virtual void deleteVertices(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::storage::cpp2::DeleteVerticesRequest& p_req); + protected: + void deleteVerticesImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::DeleteVerticesRequest& p_req); + public: + + virtual void sync_deleteVertices( ::nebula::storage::cpp2::ExecResponse& _return, const ::nebula::storage::cpp2::DeleteVerticesRequest& p_req); + virtual void sync_deleteVertices(apache::thrift::RpcOptions& rpcOptions, ::nebula::storage::cpp2::ExecResponse& _return, const ::nebula::storage::cpp2::DeleteVerticesRequest& p_req); + + virtual folly::Future< ::nebula::storage::cpp2::ExecResponse> future_deleteVertices(const ::nebula::storage::cpp2::DeleteVerticesRequest& p_req); + virtual folly::SemiFuture< ::nebula::storage::cpp2::ExecResponse> semifuture_deleteVertices(const ::nebula::storage::cpp2::DeleteVerticesRequest& p_req); + virtual folly::Future< ::nebula::storage::cpp2::ExecResponse> future_deleteVertices(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::DeleteVerticesRequest& p_req); + virtual folly::SemiFuture< ::nebula::storage::cpp2::ExecResponse> semifuture_deleteVertices(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::DeleteVerticesRequest& p_req); + virtual folly::Future>> header_future_deleteVertices(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::DeleteVerticesRequest& p_req); + virtual folly::SemiFuture>> header_semifuture_deleteVertices(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::DeleteVerticesRequest& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::storage::cpp2::ExecResponse> co_deleteVertices(const ::nebula::storage::cpp2::DeleteVerticesRequest& p_req) { + return co_deleteVertices(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::storage::cpp2::ExecResponse> co_deleteVertices(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::DeleteVerticesRequest& p_req) { + return co_deleteVertices(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::storage::cpp2::ExecResponse> co_deleteVertices(apache::thrift::RpcOptions* rpcOptions, const ::nebula::storage::cpp2::DeleteVerticesRequest& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = deleteVerticesCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + deleteVerticesImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + deleteVerticesImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::storage::cpp2::ExecResponse _return; + if (auto ew = recv_wrapped_deleteVertices(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void deleteVertices(folly::Function callback, const ::nebula::storage::cpp2::DeleteVerticesRequest& p_req); + + + static folly::exception_wrapper recv_wrapped_deleteVertices( ::nebula::storage::cpp2::ExecResponse& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_deleteVertices( ::nebula::storage::cpp2::ExecResponse& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_deleteVertices( ::nebula::storage::cpp2::ExecResponse& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_deleteVertices( ::nebula::storage::cpp2::ExecResponse& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void deleteVerticesT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::DeleteVerticesRequest& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> deleteVerticesCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void deleteTags(std::unique_ptr callback, const ::nebula::storage::cpp2::DeleteTagsRequest& p_req); + virtual void deleteTags(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::storage::cpp2::DeleteTagsRequest& p_req); + protected: + void deleteTagsImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::DeleteTagsRequest& p_req); + public: + + virtual void sync_deleteTags( ::nebula::storage::cpp2::ExecResponse& _return, const ::nebula::storage::cpp2::DeleteTagsRequest& p_req); + virtual void sync_deleteTags(apache::thrift::RpcOptions& rpcOptions, ::nebula::storage::cpp2::ExecResponse& _return, const ::nebula::storage::cpp2::DeleteTagsRequest& p_req); + + virtual folly::Future< ::nebula::storage::cpp2::ExecResponse> future_deleteTags(const ::nebula::storage::cpp2::DeleteTagsRequest& p_req); + virtual folly::SemiFuture< ::nebula::storage::cpp2::ExecResponse> semifuture_deleteTags(const ::nebula::storage::cpp2::DeleteTagsRequest& p_req); + virtual folly::Future< ::nebula::storage::cpp2::ExecResponse> future_deleteTags(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::DeleteTagsRequest& p_req); + virtual folly::SemiFuture< ::nebula::storage::cpp2::ExecResponse> semifuture_deleteTags(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::DeleteTagsRequest& p_req); + virtual folly::Future>> header_future_deleteTags(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::DeleteTagsRequest& p_req); + virtual folly::SemiFuture>> header_semifuture_deleteTags(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::DeleteTagsRequest& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::storage::cpp2::ExecResponse> co_deleteTags(const ::nebula::storage::cpp2::DeleteTagsRequest& p_req) { + return co_deleteTags(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::storage::cpp2::ExecResponse> co_deleteTags(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::DeleteTagsRequest& p_req) { + return co_deleteTags(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::storage::cpp2::ExecResponse> co_deleteTags(apache::thrift::RpcOptions* rpcOptions, const ::nebula::storage::cpp2::DeleteTagsRequest& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = deleteTagsCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + deleteTagsImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + deleteTagsImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::storage::cpp2::ExecResponse _return; + if (auto ew = recv_wrapped_deleteTags(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void deleteTags(folly::Function callback, const ::nebula::storage::cpp2::DeleteTagsRequest& p_req); + + + static folly::exception_wrapper recv_wrapped_deleteTags( ::nebula::storage::cpp2::ExecResponse& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_deleteTags( ::nebula::storage::cpp2::ExecResponse& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_deleteTags( ::nebula::storage::cpp2::ExecResponse& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_deleteTags( ::nebula::storage::cpp2::ExecResponse& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void deleteTagsT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::DeleteTagsRequest& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> deleteTagsCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void updateVertex(std::unique_ptr callback, const ::nebula::storage::cpp2::UpdateVertexRequest& p_req); + virtual void updateVertex(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::storage::cpp2::UpdateVertexRequest& p_req); + protected: + void updateVertexImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::UpdateVertexRequest& p_req); + public: + + virtual void sync_updateVertex( ::nebula::storage::cpp2::UpdateResponse& _return, const ::nebula::storage::cpp2::UpdateVertexRequest& p_req); + virtual void sync_updateVertex(apache::thrift::RpcOptions& rpcOptions, ::nebula::storage::cpp2::UpdateResponse& _return, const ::nebula::storage::cpp2::UpdateVertexRequest& p_req); + + virtual folly::Future< ::nebula::storage::cpp2::UpdateResponse> future_updateVertex(const ::nebula::storage::cpp2::UpdateVertexRequest& p_req); + virtual folly::SemiFuture< ::nebula::storage::cpp2::UpdateResponse> semifuture_updateVertex(const ::nebula::storage::cpp2::UpdateVertexRequest& p_req); + virtual folly::Future< ::nebula::storage::cpp2::UpdateResponse> future_updateVertex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::UpdateVertexRequest& p_req); + virtual folly::SemiFuture< ::nebula::storage::cpp2::UpdateResponse> semifuture_updateVertex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::UpdateVertexRequest& p_req); + virtual folly::Future>> header_future_updateVertex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::UpdateVertexRequest& p_req); + virtual folly::SemiFuture>> header_semifuture_updateVertex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::UpdateVertexRequest& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::storage::cpp2::UpdateResponse> co_updateVertex(const ::nebula::storage::cpp2::UpdateVertexRequest& p_req) { + return co_updateVertex(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::storage::cpp2::UpdateResponse> co_updateVertex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::UpdateVertexRequest& p_req) { + return co_updateVertex(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::storage::cpp2::UpdateResponse> co_updateVertex(apache::thrift::RpcOptions* rpcOptions, const ::nebula::storage::cpp2::UpdateVertexRequest& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = updateVertexCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + updateVertexImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + updateVertexImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::storage::cpp2::UpdateResponse _return; + if (auto ew = recv_wrapped_updateVertex(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void updateVertex(folly::Function callback, const ::nebula::storage::cpp2::UpdateVertexRequest& p_req); + + + static folly::exception_wrapper recv_wrapped_updateVertex( ::nebula::storage::cpp2::UpdateResponse& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_updateVertex( ::nebula::storage::cpp2::UpdateResponse& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_updateVertex( ::nebula::storage::cpp2::UpdateResponse& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_updateVertex( ::nebula::storage::cpp2::UpdateResponse& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void updateVertexT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::UpdateVertexRequest& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> updateVertexCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void updateEdge(std::unique_ptr callback, const ::nebula::storage::cpp2::UpdateEdgeRequest& p_req); + virtual void updateEdge(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::storage::cpp2::UpdateEdgeRequest& p_req); + protected: + void updateEdgeImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::UpdateEdgeRequest& p_req); + public: + + virtual void sync_updateEdge( ::nebula::storage::cpp2::UpdateResponse& _return, const ::nebula::storage::cpp2::UpdateEdgeRequest& p_req); + virtual void sync_updateEdge(apache::thrift::RpcOptions& rpcOptions, ::nebula::storage::cpp2::UpdateResponse& _return, const ::nebula::storage::cpp2::UpdateEdgeRequest& p_req); + + virtual folly::Future< ::nebula::storage::cpp2::UpdateResponse> future_updateEdge(const ::nebula::storage::cpp2::UpdateEdgeRequest& p_req); + virtual folly::SemiFuture< ::nebula::storage::cpp2::UpdateResponse> semifuture_updateEdge(const ::nebula::storage::cpp2::UpdateEdgeRequest& p_req); + virtual folly::Future< ::nebula::storage::cpp2::UpdateResponse> future_updateEdge(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::UpdateEdgeRequest& p_req); + virtual folly::SemiFuture< ::nebula::storage::cpp2::UpdateResponse> semifuture_updateEdge(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::UpdateEdgeRequest& p_req); + virtual folly::Future>> header_future_updateEdge(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::UpdateEdgeRequest& p_req); + virtual folly::SemiFuture>> header_semifuture_updateEdge(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::UpdateEdgeRequest& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::storage::cpp2::UpdateResponse> co_updateEdge(const ::nebula::storage::cpp2::UpdateEdgeRequest& p_req) { + return co_updateEdge(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::storage::cpp2::UpdateResponse> co_updateEdge(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::UpdateEdgeRequest& p_req) { + return co_updateEdge(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::storage::cpp2::UpdateResponse> co_updateEdge(apache::thrift::RpcOptions* rpcOptions, const ::nebula::storage::cpp2::UpdateEdgeRequest& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = updateEdgeCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + updateEdgeImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + updateEdgeImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::storage::cpp2::UpdateResponse _return; + if (auto ew = recv_wrapped_updateEdge(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void updateEdge(folly::Function callback, const ::nebula::storage::cpp2::UpdateEdgeRequest& p_req); + + + static folly::exception_wrapper recv_wrapped_updateEdge( ::nebula::storage::cpp2::UpdateResponse& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_updateEdge( ::nebula::storage::cpp2::UpdateResponse& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_updateEdge( ::nebula::storage::cpp2::UpdateResponse& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_updateEdge( ::nebula::storage::cpp2::UpdateResponse& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void updateEdgeT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::UpdateEdgeRequest& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> updateEdgeCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void scanVertex(std::unique_ptr callback, const ::nebula::storage::cpp2::ScanVertexRequest& p_req); + virtual void scanVertex(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::storage::cpp2::ScanVertexRequest& p_req); + protected: + void scanVertexImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::ScanVertexRequest& p_req); + public: + + virtual void sync_scanVertex( ::nebula::storage::cpp2::ScanVertexResponse& _return, const ::nebula::storage::cpp2::ScanVertexRequest& p_req); + virtual void sync_scanVertex(apache::thrift::RpcOptions& rpcOptions, ::nebula::storage::cpp2::ScanVertexResponse& _return, const ::nebula::storage::cpp2::ScanVertexRequest& p_req); + + virtual folly::Future< ::nebula::storage::cpp2::ScanVertexResponse> future_scanVertex(const ::nebula::storage::cpp2::ScanVertexRequest& p_req); + virtual folly::SemiFuture< ::nebula::storage::cpp2::ScanVertexResponse> semifuture_scanVertex(const ::nebula::storage::cpp2::ScanVertexRequest& p_req); + virtual folly::Future< ::nebula::storage::cpp2::ScanVertexResponse> future_scanVertex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::ScanVertexRequest& p_req); + virtual folly::SemiFuture< ::nebula::storage::cpp2::ScanVertexResponse> semifuture_scanVertex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::ScanVertexRequest& p_req); + virtual folly::Future>> header_future_scanVertex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::ScanVertexRequest& p_req); + virtual folly::SemiFuture>> header_semifuture_scanVertex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::ScanVertexRequest& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::storage::cpp2::ScanVertexResponse> co_scanVertex(const ::nebula::storage::cpp2::ScanVertexRequest& p_req) { + return co_scanVertex(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::storage::cpp2::ScanVertexResponse> co_scanVertex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::ScanVertexRequest& p_req) { + return co_scanVertex(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::storage::cpp2::ScanVertexResponse> co_scanVertex(apache::thrift::RpcOptions* rpcOptions, const ::nebula::storage::cpp2::ScanVertexRequest& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = scanVertexCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + scanVertexImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + scanVertexImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::storage::cpp2::ScanVertexResponse _return; + if (auto ew = recv_wrapped_scanVertex(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void scanVertex(folly::Function callback, const ::nebula::storage::cpp2::ScanVertexRequest& p_req); + + + static folly::exception_wrapper recv_wrapped_scanVertex( ::nebula::storage::cpp2::ScanVertexResponse& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_scanVertex( ::nebula::storage::cpp2::ScanVertexResponse& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_scanVertex( ::nebula::storage::cpp2::ScanVertexResponse& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_scanVertex( ::nebula::storage::cpp2::ScanVertexResponse& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void scanVertexT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::ScanVertexRequest& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> scanVertexCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void scanEdge(std::unique_ptr callback, const ::nebula::storage::cpp2::ScanEdgeRequest& p_req); + virtual void scanEdge(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::storage::cpp2::ScanEdgeRequest& p_req); + protected: + void scanEdgeImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::ScanEdgeRequest& p_req); + public: + + virtual void sync_scanEdge( ::nebula::storage::cpp2::ScanEdgeResponse& _return, const ::nebula::storage::cpp2::ScanEdgeRequest& p_req); + virtual void sync_scanEdge(apache::thrift::RpcOptions& rpcOptions, ::nebula::storage::cpp2::ScanEdgeResponse& _return, const ::nebula::storage::cpp2::ScanEdgeRequest& p_req); + + virtual folly::Future< ::nebula::storage::cpp2::ScanEdgeResponse> future_scanEdge(const ::nebula::storage::cpp2::ScanEdgeRequest& p_req); + virtual folly::SemiFuture< ::nebula::storage::cpp2::ScanEdgeResponse> semifuture_scanEdge(const ::nebula::storage::cpp2::ScanEdgeRequest& p_req); + virtual folly::Future< ::nebula::storage::cpp2::ScanEdgeResponse> future_scanEdge(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::ScanEdgeRequest& p_req); + virtual folly::SemiFuture< ::nebula::storage::cpp2::ScanEdgeResponse> semifuture_scanEdge(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::ScanEdgeRequest& p_req); + virtual folly::Future>> header_future_scanEdge(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::ScanEdgeRequest& p_req); + virtual folly::SemiFuture>> header_semifuture_scanEdge(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::ScanEdgeRequest& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::storage::cpp2::ScanEdgeResponse> co_scanEdge(const ::nebula::storage::cpp2::ScanEdgeRequest& p_req) { + return co_scanEdge(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::storage::cpp2::ScanEdgeResponse> co_scanEdge(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::ScanEdgeRequest& p_req) { + return co_scanEdge(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::storage::cpp2::ScanEdgeResponse> co_scanEdge(apache::thrift::RpcOptions* rpcOptions, const ::nebula::storage::cpp2::ScanEdgeRequest& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = scanEdgeCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + scanEdgeImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + scanEdgeImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::storage::cpp2::ScanEdgeResponse _return; + if (auto ew = recv_wrapped_scanEdge(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void scanEdge(folly::Function callback, const ::nebula::storage::cpp2::ScanEdgeRequest& p_req); + + + static folly::exception_wrapper recv_wrapped_scanEdge( ::nebula::storage::cpp2::ScanEdgeResponse& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_scanEdge( ::nebula::storage::cpp2::ScanEdgeResponse& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_scanEdge( ::nebula::storage::cpp2::ScanEdgeResponse& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_scanEdge( ::nebula::storage::cpp2::ScanEdgeResponse& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void scanEdgeT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::ScanEdgeRequest& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> scanEdgeCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void getUUID(std::unique_ptr callback, const ::nebula::storage::cpp2::GetUUIDReq& p_req); + virtual void getUUID(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::storage::cpp2::GetUUIDReq& p_req); + protected: + void getUUIDImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::GetUUIDReq& p_req); + public: + + virtual void sync_getUUID( ::nebula::storage::cpp2::GetUUIDResp& _return, const ::nebula::storage::cpp2::GetUUIDReq& p_req); + virtual void sync_getUUID(apache::thrift::RpcOptions& rpcOptions, ::nebula::storage::cpp2::GetUUIDResp& _return, const ::nebula::storage::cpp2::GetUUIDReq& p_req); + + virtual folly::Future< ::nebula::storage::cpp2::GetUUIDResp> future_getUUID(const ::nebula::storage::cpp2::GetUUIDReq& p_req); + virtual folly::SemiFuture< ::nebula::storage::cpp2::GetUUIDResp> semifuture_getUUID(const ::nebula::storage::cpp2::GetUUIDReq& p_req); + virtual folly::Future< ::nebula::storage::cpp2::GetUUIDResp> future_getUUID(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::GetUUIDReq& p_req); + virtual folly::SemiFuture< ::nebula::storage::cpp2::GetUUIDResp> semifuture_getUUID(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::GetUUIDReq& p_req); + virtual folly::Future>> header_future_getUUID(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::GetUUIDReq& p_req); + virtual folly::SemiFuture>> header_semifuture_getUUID(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::GetUUIDReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::storage::cpp2::GetUUIDResp> co_getUUID(const ::nebula::storage::cpp2::GetUUIDReq& p_req) { + return co_getUUID(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::storage::cpp2::GetUUIDResp> co_getUUID(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::GetUUIDReq& p_req) { + return co_getUUID(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::storage::cpp2::GetUUIDResp> co_getUUID(apache::thrift::RpcOptions* rpcOptions, const ::nebula::storage::cpp2::GetUUIDReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = getUUIDCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + getUUIDImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + getUUIDImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::storage::cpp2::GetUUIDResp _return; + if (auto ew = recv_wrapped_getUUID(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void getUUID(folly::Function callback, const ::nebula::storage::cpp2::GetUUIDReq& p_req); + + + static folly::exception_wrapper recv_wrapped_getUUID( ::nebula::storage::cpp2::GetUUIDResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_getUUID( ::nebula::storage::cpp2::GetUUIDResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_getUUID( ::nebula::storage::cpp2::GetUUIDResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_getUUID( ::nebula::storage::cpp2::GetUUIDResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void getUUIDT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::GetUUIDReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> getUUIDCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void lookupIndex(std::unique_ptr callback, const ::nebula::storage::cpp2::LookupIndexRequest& p_req); + virtual void lookupIndex(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::storage::cpp2::LookupIndexRequest& p_req); + protected: + void lookupIndexImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::LookupIndexRequest& p_req); + public: + + virtual void sync_lookupIndex( ::nebula::storage::cpp2::LookupIndexResp& _return, const ::nebula::storage::cpp2::LookupIndexRequest& p_req); + virtual void sync_lookupIndex(apache::thrift::RpcOptions& rpcOptions, ::nebula::storage::cpp2::LookupIndexResp& _return, const ::nebula::storage::cpp2::LookupIndexRequest& p_req); + + virtual folly::Future< ::nebula::storage::cpp2::LookupIndexResp> future_lookupIndex(const ::nebula::storage::cpp2::LookupIndexRequest& p_req); + virtual folly::SemiFuture< ::nebula::storage::cpp2::LookupIndexResp> semifuture_lookupIndex(const ::nebula::storage::cpp2::LookupIndexRequest& p_req); + virtual folly::Future< ::nebula::storage::cpp2::LookupIndexResp> future_lookupIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::LookupIndexRequest& p_req); + virtual folly::SemiFuture< ::nebula::storage::cpp2::LookupIndexResp> semifuture_lookupIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::LookupIndexRequest& p_req); + virtual folly::Future>> header_future_lookupIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::LookupIndexRequest& p_req); + virtual folly::SemiFuture>> header_semifuture_lookupIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::LookupIndexRequest& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::storage::cpp2::LookupIndexResp> co_lookupIndex(const ::nebula::storage::cpp2::LookupIndexRequest& p_req) { + return co_lookupIndex(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::storage::cpp2::LookupIndexResp> co_lookupIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::LookupIndexRequest& p_req) { + return co_lookupIndex(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::storage::cpp2::LookupIndexResp> co_lookupIndex(apache::thrift::RpcOptions* rpcOptions, const ::nebula::storage::cpp2::LookupIndexRequest& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = lookupIndexCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + lookupIndexImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + lookupIndexImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::storage::cpp2::LookupIndexResp _return; + if (auto ew = recv_wrapped_lookupIndex(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void lookupIndex(folly::Function callback, const ::nebula::storage::cpp2::LookupIndexRequest& p_req); + + + static folly::exception_wrapper recv_wrapped_lookupIndex( ::nebula::storage::cpp2::LookupIndexResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_lookupIndex( ::nebula::storage::cpp2::LookupIndexResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_lookupIndex( ::nebula::storage::cpp2::LookupIndexResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_lookupIndex( ::nebula::storage::cpp2::LookupIndexResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void lookupIndexT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::LookupIndexRequest& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> lookupIndexCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void lookupAndTraverse(std::unique_ptr callback, const ::nebula::storage::cpp2::LookupAndTraverseRequest& p_req); + virtual void lookupAndTraverse(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::storage::cpp2::LookupAndTraverseRequest& p_req); + protected: + void lookupAndTraverseImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::LookupAndTraverseRequest& p_req); + public: + + virtual void sync_lookupAndTraverse( ::nebula::storage::cpp2::GetNeighborsResponse& _return, const ::nebula::storage::cpp2::LookupAndTraverseRequest& p_req); + virtual void sync_lookupAndTraverse(apache::thrift::RpcOptions& rpcOptions, ::nebula::storage::cpp2::GetNeighborsResponse& _return, const ::nebula::storage::cpp2::LookupAndTraverseRequest& p_req); + + virtual folly::Future< ::nebula::storage::cpp2::GetNeighborsResponse> future_lookupAndTraverse(const ::nebula::storage::cpp2::LookupAndTraverseRequest& p_req); + virtual folly::SemiFuture< ::nebula::storage::cpp2::GetNeighborsResponse> semifuture_lookupAndTraverse(const ::nebula::storage::cpp2::LookupAndTraverseRequest& p_req); + virtual folly::Future< ::nebula::storage::cpp2::GetNeighborsResponse> future_lookupAndTraverse(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::LookupAndTraverseRequest& p_req); + virtual folly::SemiFuture< ::nebula::storage::cpp2::GetNeighborsResponse> semifuture_lookupAndTraverse(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::LookupAndTraverseRequest& p_req); + virtual folly::Future>> header_future_lookupAndTraverse(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::LookupAndTraverseRequest& p_req); + virtual folly::SemiFuture>> header_semifuture_lookupAndTraverse(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::LookupAndTraverseRequest& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::storage::cpp2::GetNeighborsResponse> co_lookupAndTraverse(const ::nebula::storage::cpp2::LookupAndTraverseRequest& p_req) { + return co_lookupAndTraverse(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::storage::cpp2::GetNeighborsResponse> co_lookupAndTraverse(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::LookupAndTraverseRequest& p_req) { + return co_lookupAndTraverse(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::storage::cpp2::GetNeighborsResponse> co_lookupAndTraverse(apache::thrift::RpcOptions* rpcOptions, const ::nebula::storage::cpp2::LookupAndTraverseRequest& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = lookupAndTraverseCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + lookupAndTraverseImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + lookupAndTraverseImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::storage::cpp2::GetNeighborsResponse _return; + if (auto ew = recv_wrapped_lookupAndTraverse(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void lookupAndTraverse(folly::Function callback, const ::nebula::storage::cpp2::LookupAndTraverseRequest& p_req); + + + static folly::exception_wrapper recv_wrapped_lookupAndTraverse( ::nebula::storage::cpp2::GetNeighborsResponse& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_lookupAndTraverse( ::nebula::storage::cpp2::GetNeighborsResponse& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_lookupAndTraverse( ::nebula::storage::cpp2::GetNeighborsResponse& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_lookupAndTraverse( ::nebula::storage::cpp2::GetNeighborsResponse& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void lookupAndTraverseT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::LookupAndTraverseRequest& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> lookupAndTraverseCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void chainUpdateEdge(std::unique_ptr callback, const ::nebula::storage::cpp2::UpdateEdgeRequest& p_req); + virtual void chainUpdateEdge(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::storage::cpp2::UpdateEdgeRequest& p_req); + protected: + void chainUpdateEdgeImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::UpdateEdgeRequest& p_req); + public: + + virtual void sync_chainUpdateEdge( ::nebula::storage::cpp2::UpdateResponse& _return, const ::nebula::storage::cpp2::UpdateEdgeRequest& p_req); + virtual void sync_chainUpdateEdge(apache::thrift::RpcOptions& rpcOptions, ::nebula::storage::cpp2::UpdateResponse& _return, const ::nebula::storage::cpp2::UpdateEdgeRequest& p_req); + + virtual folly::Future< ::nebula::storage::cpp2::UpdateResponse> future_chainUpdateEdge(const ::nebula::storage::cpp2::UpdateEdgeRequest& p_req); + virtual folly::SemiFuture< ::nebula::storage::cpp2::UpdateResponse> semifuture_chainUpdateEdge(const ::nebula::storage::cpp2::UpdateEdgeRequest& p_req); + virtual folly::Future< ::nebula::storage::cpp2::UpdateResponse> future_chainUpdateEdge(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::UpdateEdgeRequest& p_req); + virtual folly::SemiFuture< ::nebula::storage::cpp2::UpdateResponse> semifuture_chainUpdateEdge(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::UpdateEdgeRequest& p_req); + virtual folly::Future>> header_future_chainUpdateEdge(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::UpdateEdgeRequest& p_req); + virtual folly::SemiFuture>> header_semifuture_chainUpdateEdge(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::UpdateEdgeRequest& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::storage::cpp2::UpdateResponse> co_chainUpdateEdge(const ::nebula::storage::cpp2::UpdateEdgeRequest& p_req) { + return co_chainUpdateEdge(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::storage::cpp2::UpdateResponse> co_chainUpdateEdge(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::UpdateEdgeRequest& p_req) { + return co_chainUpdateEdge(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::storage::cpp2::UpdateResponse> co_chainUpdateEdge(apache::thrift::RpcOptions* rpcOptions, const ::nebula::storage::cpp2::UpdateEdgeRequest& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = chainUpdateEdgeCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + chainUpdateEdgeImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + chainUpdateEdgeImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::storage::cpp2::UpdateResponse _return; + if (auto ew = recv_wrapped_chainUpdateEdge(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void chainUpdateEdge(folly::Function callback, const ::nebula::storage::cpp2::UpdateEdgeRequest& p_req); + + + static folly::exception_wrapper recv_wrapped_chainUpdateEdge( ::nebula::storage::cpp2::UpdateResponse& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_chainUpdateEdge( ::nebula::storage::cpp2::UpdateResponse& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_chainUpdateEdge( ::nebula::storage::cpp2::UpdateResponse& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_chainUpdateEdge( ::nebula::storage::cpp2::UpdateResponse& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void chainUpdateEdgeT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::UpdateEdgeRequest& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> chainUpdateEdgeCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void chainAddEdges(std::unique_ptr callback, const ::nebula::storage::cpp2::AddEdgesRequest& p_req); + virtual void chainAddEdges(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::storage::cpp2::AddEdgesRequest& p_req); + protected: + void chainAddEdgesImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::AddEdgesRequest& p_req); + public: + + virtual void sync_chainAddEdges( ::nebula::storage::cpp2::ExecResponse& _return, const ::nebula::storage::cpp2::AddEdgesRequest& p_req); + virtual void sync_chainAddEdges(apache::thrift::RpcOptions& rpcOptions, ::nebula::storage::cpp2::ExecResponse& _return, const ::nebula::storage::cpp2::AddEdgesRequest& p_req); + + virtual folly::Future< ::nebula::storage::cpp2::ExecResponse> future_chainAddEdges(const ::nebula::storage::cpp2::AddEdgesRequest& p_req); + virtual folly::SemiFuture< ::nebula::storage::cpp2::ExecResponse> semifuture_chainAddEdges(const ::nebula::storage::cpp2::AddEdgesRequest& p_req); + virtual folly::Future< ::nebula::storage::cpp2::ExecResponse> future_chainAddEdges(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::AddEdgesRequest& p_req); + virtual folly::SemiFuture< ::nebula::storage::cpp2::ExecResponse> semifuture_chainAddEdges(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::AddEdgesRequest& p_req); + virtual folly::Future>> header_future_chainAddEdges(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::AddEdgesRequest& p_req); + virtual folly::SemiFuture>> header_semifuture_chainAddEdges(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::AddEdgesRequest& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::storage::cpp2::ExecResponse> co_chainAddEdges(const ::nebula::storage::cpp2::AddEdgesRequest& p_req) { + return co_chainAddEdges(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::storage::cpp2::ExecResponse> co_chainAddEdges(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::AddEdgesRequest& p_req) { + return co_chainAddEdges(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::storage::cpp2::ExecResponse> co_chainAddEdges(apache::thrift::RpcOptions* rpcOptions, const ::nebula::storage::cpp2::AddEdgesRequest& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = chainAddEdgesCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + chainAddEdgesImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + chainAddEdgesImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::storage::cpp2::ExecResponse _return; + if (auto ew = recv_wrapped_chainAddEdges(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void chainAddEdges(folly::Function callback, const ::nebula::storage::cpp2::AddEdgesRequest& p_req); + + + static folly::exception_wrapper recv_wrapped_chainAddEdges( ::nebula::storage::cpp2::ExecResponse& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_chainAddEdges( ::nebula::storage::cpp2::ExecResponse& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_chainAddEdges( ::nebula::storage::cpp2::ExecResponse& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_chainAddEdges( ::nebula::storage::cpp2::ExecResponse& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void chainAddEdgesT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::AddEdgesRequest& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> chainAddEdgesCtx(apache::thrift::RpcOptions* rpcOptions); + public: +}; + +}}} // nebula::storage::cpp2 diff --git a/src/interface/gen-cpp2/GraphStorageService_custom_protocol.h b/src/interface/gen-cpp2/GraphStorageService_custom_protocol.h new file mode 100644 index 00000000..374e62a9 --- /dev/null +++ b/src/interface/gen-cpp2/GraphStorageService_custom_protocol.h @@ -0,0 +1,19 @@ +/** + * Autogenerated by Thrift for storage.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#pragma once + +/** + * This header file includes the tcc files of the corresponding header file + * and the header files of its dependent types. Include this header file + * only when you need to use custom protocols (e.g. DebugProtocol, + * VirtualProtocol) to read/write thrift structs. + */ + +#include "GraphStorageService.tcc" +#include "storage_types_custom_protocol.h" +#include "common_types_custom_protocol.h" +#include "meta_types_custom_protocol.h" diff --git a/src/interface/gen-cpp2/GraphStorageService_processmap_binary.cpp b/src/interface/gen-cpp2/GraphStorageService_processmap_binary.cpp new file mode 100644 index 00000000..ea61a3bb --- /dev/null +++ b/src/interface/gen-cpp2/GraphStorageService_processmap_binary.cpp @@ -0,0 +1,12 @@ +/** + * Autogenerated by Thrift for storage.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ + +#include "GraphStorageService.h" +#include "GraphStorageService.tcc" + +namespace nebula { namespace storage { namespace cpp2 { +}}} // nebula::storage::cpp2 diff --git a/src/interface/gen-cpp2/GraphStorageService_processmap_compact.cpp b/src/interface/gen-cpp2/GraphStorageService_processmap_compact.cpp new file mode 100644 index 00000000..ea61a3bb --- /dev/null +++ b/src/interface/gen-cpp2/GraphStorageService_processmap_compact.cpp @@ -0,0 +1,12 @@ +/** + * Autogenerated by Thrift for storage.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ + +#include "GraphStorageService.h" +#include "GraphStorageService.tcc" + +namespace nebula { namespace storage { namespace cpp2 { +}}} // nebula::storage::cpp2 diff --git a/src/interface/gen-cpp2/InternalStorageService.cpp b/src/interface/gen-cpp2/InternalStorageService.cpp new file mode 100644 index 00000000..d68c707d --- /dev/null +++ b/src/interface/gen-cpp2/InternalStorageService.cpp @@ -0,0 +1,100 @@ +/** + * Autogenerated by Thrift for storage.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#include "InternalStorageService.h" +#include "InternalStorageService.tcc" +#include "storage_metadata.h" +#include + +namespace nebula { namespace storage { namespace cpp2 { +std::unique_ptr InternalStorageServiceSvIf::getProcessor() { + return std::make_unique(this); +} + + +void InternalStorageServiceSvIf::chainAddEdges( ::nebula::storage::cpp2::ExecResponse& /*_return*/, const ::nebula::storage::cpp2::ChainAddEdgesRequest& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("chainAddEdges"); +} + +folly::SemiFuture< ::nebula::storage::cpp2::ExecResponse> InternalStorageServiceSvIf::semifuture_chainAddEdges(const ::nebula::storage::cpp2::ChainAddEdgesRequest& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::storage::cpp2::ExecResponse& _return) { chainAddEdges(_return, p_req); }); +} + +folly::Future< ::nebula::storage::cpp2::ExecResponse> InternalStorageServiceSvIf::future_chainAddEdges(const ::nebula::storage::cpp2::ChainAddEdgesRequest& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_chainAddEdges(p_req), std::move(ka)); +} + +void InternalStorageServiceSvIf::async_tm_chainAddEdges(std::unique_ptr> callback, const ::nebula::storage::cpp2::ChainAddEdgesRequest& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_chainAddEdges(p_req); + }); +} + +void InternalStorageServiceSvIf::chainUpdateEdge( ::nebula::storage::cpp2::UpdateResponse& /*_return*/, const ::nebula::storage::cpp2::ChainUpdateEdgeRequest& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("chainUpdateEdge"); +} + +folly::SemiFuture< ::nebula::storage::cpp2::UpdateResponse> InternalStorageServiceSvIf::semifuture_chainUpdateEdge(const ::nebula::storage::cpp2::ChainUpdateEdgeRequest& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::storage::cpp2::UpdateResponse& _return) { chainUpdateEdge(_return, p_req); }); +} + +folly::Future< ::nebula::storage::cpp2::UpdateResponse> InternalStorageServiceSvIf::future_chainUpdateEdge(const ::nebula::storage::cpp2::ChainUpdateEdgeRequest& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_chainUpdateEdge(p_req), std::move(ka)); +} + +void InternalStorageServiceSvIf::async_tm_chainUpdateEdge(std::unique_ptr> callback, const ::nebula::storage::cpp2::ChainUpdateEdgeRequest& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_chainUpdateEdge(p_req); + }); +} + +void InternalStorageServiceSvNull::chainAddEdges( ::nebula::storage::cpp2::ExecResponse& /*_return*/, const ::nebula::storage::cpp2::ChainAddEdgesRequest& /*req*/) {} + +void InternalStorageServiceSvNull::chainUpdateEdge( ::nebula::storage::cpp2::UpdateResponse& /*_return*/, const ::nebula::storage::cpp2::ChainUpdateEdgeRequest& /*req*/) {} + + + +const char* InternalStorageServiceAsyncProcessor::getServiceName() { + return "InternalStorageService"; +} + +void InternalStorageServiceAsyncProcessor::getServiceMetadata(apache::thrift::metadata::ThriftServiceMetadataResponse& response) { + ::apache::thrift::detail::md::ServiceMetadata::gen(*response.metadata_ref(), *response.context_ref()); +} + +void InternalStorageServiceAsyncProcessor::processSerializedRequest(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::protocol::PROTOCOL_TYPES protType, apache::thrift::Cpp2RequestContext* context, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + apache::thrift::detail::ap::process(this, std::move(req), std::move(serializedRequest), protType, context, eb, tm); +} + +std::shared_ptr InternalStorageServiceAsyncProcessor::getBaseContextForRequest() { + return iface_->getBaseContextForRequest(); +} + +const InternalStorageServiceAsyncProcessor::ProcessMap& InternalStorageServiceAsyncProcessor::getBinaryProtocolProcessMap() { + return binaryProcessMap_; +} + +const InternalStorageServiceAsyncProcessor::ProcessMap InternalStorageServiceAsyncProcessor::binaryProcessMap_ { + {"chainAddEdges", &InternalStorageServiceAsyncProcessor::setUpAndProcess_chainAddEdges}, + {"chainUpdateEdge", &InternalStorageServiceAsyncProcessor::setUpAndProcess_chainUpdateEdge}, +}; + +const InternalStorageServiceAsyncProcessor::ProcessMap& InternalStorageServiceAsyncProcessor::getCompactProtocolProcessMap() { + return compactProcessMap_; +} + +const InternalStorageServiceAsyncProcessor::ProcessMap InternalStorageServiceAsyncProcessor::compactProcessMap_ { + {"chainAddEdges", &InternalStorageServiceAsyncProcessor::setUpAndProcess_chainAddEdges}, + {"chainUpdateEdge", &InternalStorageServiceAsyncProcessor::setUpAndProcess_chainUpdateEdge}, +}; + +}}} // nebula::storage::cpp2 diff --git a/src/interface/gen-cpp2/InternalStorageService.h b/src/interface/gen-cpp2/InternalStorageService.h new file mode 100644 index 00000000..3048de9d --- /dev/null +++ b/src/interface/gen-cpp2/InternalStorageService.h @@ -0,0 +1,107 @@ +/** + * Autogenerated by Thrift for storage.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#pragma once + +#include + +#include "InternalStorageServiceAsyncClient.h" +#include "storage_types.h" +#include "common_types.h" +#include "meta_types.h" + +namespace folly { + class IOBuf; + class IOBufQueue; +} +namespace apache { namespace thrift { + class Cpp2RequestContext; + class BinaryProtocolReader; + class CompactProtocolReader; + namespace transport { class THeader; } +}} + +namespace nebula { namespace storage { namespace cpp2 { + +class InternalStorageServiceSvAsyncIf { + public: + virtual ~InternalStorageServiceSvAsyncIf() {} + virtual void async_tm_chainAddEdges(std::unique_ptr> callback, const ::nebula::storage::cpp2::ChainAddEdgesRequest& p_req) = 0; + virtual folly::Future< ::nebula::storage::cpp2::ExecResponse> future_chainAddEdges(const ::nebula::storage::cpp2::ChainAddEdgesRequest& p_req) = 0; + virtual folly::SemiFuture< ::nebula::storage::cpp2::ExecResponse> semifuture_chainAddEdges(const ::nebula::storage::cpp2::ChainAddEdgesRequest& p_req) = 0; + virtual void async_tm_chainUpdateEdge(std::unique_ptr> callback, const ::nebula::storage::cpp2::ChainUpdateEdgeRequest& p_req) = 0; + virtual folly::Future< ::nebula::storage::cpp2::UpdateResponse> future_chainUpdateEdge(const ::nebula::storage::cpp2::ChainUpdateEdgeRequest& p_req) = 0; + virtual folly::SemiFuture< ::nebula::storage::cpp2::UpdateResponse> semifuture_chainUpdateEdge(const ::nebula::storage::cpp2::ChainUpdateEdgeRequest& p_req) = 0; +}; + +class InternalStorageServiceAsyncProcessor; + +class InternalStorageServiceSvIf : public InternalStorageServiceSvAsyncIf, public apache::thrift::ServerInterface { + public: + typedef InternalStorageServiceAsyncProcessor ProcessorType; + std::unique_ptr getProcessor() override; + + + virtual void chainAddEdges( ::nebula::storage::cpp2::ExecResponse& /*_return*/, const ::nebula::storage::cpp2::ChainAddEdgesRequest& /*req*/); + folly::Future< ::nebula::storage::cpp2::ExecResponse> future_chainAddEdges(const ::nebula::storage::cpp2::ChainAddEdgesRequest& p_req) override; + folly::SemiFuture< ::nebula::storage::cpp2::ExecResponse> semifuture_chainAddEdges(const ::nebula::storage::cpp2::ChainAddEdgesRequest& p_req) override; + void async_tm_chainAddEdges(std::unique_ptr> callback, const ::nebula::storage::cpp2::ChainAddEdgesRequest& p_req) override; + virtual void chainUpdateEdge( ::nebula::storage::cpp2::UpdateResponse& /*_return*/, const ::nebula::storage::cpp2::ChainUpdateEdgeRequest& /*req*/); + folly::Future< ::nebula::storage::cpp2::UpdateResponse> future_chainUpdateEdge(const ::nebula::storage::cpp2::ChainUpdateEdgeRequest& p_req) override; + folly::SemiFuture< ::nebula::storage::cpp2::UpdateResponse> semifuture_chainUpdateEdge(const ::nebula::storage::cpp2::ChainUpdateEdgeRequest& p_req) override; + void async_tm_chainUpdateEdge(std::unique_ptr> callback, const ::nebula::storage::cpp2::ChainUpdateEdgeRequest& p_req) override; +}; + +class InternalStorageServiceSvNull : public InternalStorageServiceSvIf { + public: + void chainAddEdges( ::nebula::storage::cpp2::ExecResponse& /*_return*/, const ::nebula::storage::cpp2::ChainAddEdgesRequest& /*req*/) override; + void chainUpdateEdge( ::nebula::storage::cpp2::UpdateResponse& /*_return*/, const ::nebula::storage::cpp2::ChainUpdateEdgeRequest& /*req*/) override; +}; + +class InternalStorageServiceAsyncProcessor : public ::apache::thrift::GeneratedAsyncProcessor { + public: + const char* getServiceName() override; + void getServiceMetadata(apache::thrift::metadata::ThriftServiceMetadataResponse& response) override; + using BaseAsyncProcessor = void; + protected: + InternalStorageServiceSvIf* iface_; + public: + void processSerializedRequest(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::protocol::PROTOCOL_TYPES protType, apache::thrift::Cpp2RequestContext* context, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) override; + protected: + std::shared_ptr getBaseContextForRequest() override; + public: + using ProcessFunc = GeneratedAsyncProcessor::ProcessFunc; + using ProcessMap = GeneratedAsyncProcessor::ProcessMap; + static const InternalStorageServiceAsyncProcessor::ProcessMap& getBinaryProtocolProcessMap(); + static const InternalStorageServiceAsyncProcessor::ProcessMap& getCompactProtocolProcessMap(); + private: + static const InternalStorageServiceAsyncProcessor::ProcessMap binaryProcessMap_; + static const InternalStorageServiceAsyncProcessor::ProcessMap compactProcessMap_; + private: + template + void setUpAndProcess_chainAddEdges(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_chainAddEdges(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_chainAddEdges(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::storage::cpp2::ExecResponse const& _return); + template + static void throw_wrapped_chainAddEdges(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_chainUpdateEdge(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_chainUpdateEdge(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_chainUpdateEdge(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::storage::cpp2::UpdateResponse const& _return); + template + static void throw_wrapped_chainUpdateEdge(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + public: + InternalStorageServiceAsyncProcessor(InternalStorageServiceSvIf* iface) : + iface_(iface) {} + + virtual ~InternalStorageServiceAsyncProcessor() {} +}; + +}}} // nebula::storage::cpp2 diff --git a/src/interface/gen-cpp2/InternalStorageService.tcc b/src/interface/gen-cpp2/InternalStorageService.tcc new file mode 100644 index 00000000..b3dda8ac --- /dev/null +++ b/src/interface/gen-cpp2/InternalStorageService.tcc @@ -0,0 +1,133 @@ +/** + * Autogenerated by Thrift for storage.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#pragma once + +#include "InternalStorageService.h" + +#include + +namespace nebula { namespace storage { namespace cpp2 { +typedef apache::thrift::ThriftPresult> InternalStorageService_chainAddEdges_pargs; +typedef apache::thrift::ThriftPresult> InternalStorageService_chainAddEdges_presult; +typedef apache::thrift::ThriftPresult> InternalStorageService_chainUpdateEdge_pargs; +typedef apache::thrift::ThriftPresult> InternalStorageService_chainUpdateEdge_presult; +template +void InternalStorageServiceAsyncProcessor::setUpAndProcess_chainAddEdges(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &InternalStorageServiceAsyncProcessor::process_chainAddEdges, this); +} + +template +void InternalStorageServiceAsyncProcessor::process_chainAddEdges(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + InternalStorageService_chainAddEdges_pargs args; + ::nebula::storage::cpp2::ChainAddEdgesRequest uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "InternalStorageService.chainAddEdges", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "chainAddEdges"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_chainAddEdges, throw_wrapped_chainAddEdges, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_chainAddEdges(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue InternalStorageServiceAsyncProcessor::return_chainAddEdges(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::storage::cpp2::ExecResponse const& _return) { + ProtocolOut_ prot; + InternalStorageService_chainAddEdges_presult result; + result.get<0>().value = const_cast< ::nebula::storage::cpp2::ExecResponse*>(&_return); + result.setIsSet(0, true); + return serializeResponse("chainAddEdges", &prot, protoSeqId, ctx, result); +} + +template +void InternalStorageServiceAsyncProcessor::throw_wrapped_chainAddEdges(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "chainAddEdges"); + return; + } +} + +template +void InternalStorageServiceAsyncProcessor::setUpAndProcess_chainUpdateEdge(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &InternalStorageServiceAsyncProcessor::process_chainUpdateEdge, this); +} + +template +void InternalStorageServiceAsyncProcessor::process_chainUpdateEdge(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + InternalStorageService_chainUpdateEdge_pargs args; + ::nebula::storage::cpp2::ChainUpdateEdgeRequest uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "InternalStorageService.chainUpdateEdge", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "chainUpdateEdge"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_chainUpdateEdge, throw_wrapped_chainUpdateEdge, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_chainUpdateEdge(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue InternalStorageServiceAsyncProcessor::return_chainUpdateEdge(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::storage::cpp2::UpdateResponse const& _return) { + ProtocolOut_ prot; + InternalStorageService_chainUpdateEdge_presult result; + result.get<0>().value = const_cast< ::nebula::storage::cpp2::UpdateResponse*>(&_return); + result.setIsSet(0, true); + return serializeResponse("chainUpdateEdge", &prot, protoSeqId, ctx, result); +} + +template +void InternalStorageServiceAsyncProcessor::throw_wrapped_chainUpdateEdge(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "chainUpdateEdge"); + return; + } +} + + +}}} // nebula::storage::cpp2 diff --git a/src/interface/gen-cpp2/InternalStorageServiceAsyncClient.cpp b/src/interface/gen-cpp2/InternalStorageServiceAsyncClient.cpp new file mode 100644 index 00000000..4bf340fa --- /dev/null +++ b/src/interface/gen-cpp2/InternalStorageServiceAsyncClient.cpp @@ -0,0 +1,381 @@ +/** + * Autogenerated by Thrift for storage.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ + +#include "InternalStorageServiceAsyncClient.h" + +#include + +namespace nebula { namespace storage { namespace cpp2 { +typedef apache::thrift::ThriftPresult> InternalStorageService_chainAddEdges_pargs; +typedef apache::thrift::ThriftPresult> InternalStorageService_chainAddEdges_presult; +typedef apache::thrift::ThriftPresult> InternalStorageService_chainUpdateEdge_pargs; +typedef apache::thrift::ThriftPresult> InternalStorageService_chainUpdateEdge_presult; + +template +void InternalStorageServiceAsyncClient::chainAddEdgesT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::ChainAddEdgesRequest& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + InternalStorageService_chainAddEdges_pargs args; + args.get<0>().value = const_cast< ::nebula::storage::cpp2::ChainAddEdgesRequest*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "chainAddEdges"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void InternalStorageServiceAsyncClient::chainUpdateEdgeT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::ChainUpdateEdgeRequest& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + InternalStorageService_chainUpdateEdge_pargs args; + args.get<0>().value = const_cast< ::nebula::storage::cpp2::ChainUpdateEdgeRequest*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "chainUpdateEdge"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + + + +void InternalStorageServiceAsyncClient::chainAddEdges(std::unique_ptr callback, const ::nebula::storage::cpp2::ChainAddEdgesRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + chainAddEdges(rpcOptions, std::move(callback), p_req); +} + +void InternalStorageServiceAsyncClient::chainAddEdges(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::storage::cpp2::ChainAddEdgesRequest& p_req) { + auto ctx = chainAddEdgesCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + chainAddEdgesImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void InternalStorageServiceAsyncClient::chainAddEdgesImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::ChainAddEdgesRequest& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + chainAddEdgesT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + chainAddEdgesT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> InternalStorageServiceAsyncClient::chainAddEdgesCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "InternalStorageService.chainAddEdges"); +} + +void InternalStorageServiceAsyncClient::sync_chainAddEdges( ::nebula::storage::cpp2::ExecResponse& _return, const ::nebula::storage::cpp2::ChainAddEdgesRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_chainAddEdges(rpcOptions, _return, p_req); +} + +void InternalStorageServiceAsyncClient::sync_chainAddEdges(apache::thrift::RpcOptions& rpcOptions, ::nebula::storage::cpp2::ExecResponse& _return, const ::nebula::storage::cpp2::ChainAddEdgesRequest& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = chainAddEdgesCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + chainAddEdgesImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_chainAddEdges(_return, returnState); + }); +} + + +folly::Future< ::nebula::storage::cpp2::ExecResponse> InternalStorageServiceAsyncClient::future_chainAddEdges(const ::nebula::storage::cpp2::ChainAddEdgesRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_chainAddEdges(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::storage::cpp2::ExecResponse> InternalStorageServiceAsyncClient::semifuture_chainAddEdges(const ::nebula::storage::cpp2::ChainAddEdgesRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_chainAddEdges(rpcOptions, p_req); +} + +folly::Future< ::nebula::storage::cpp2::ExecResponse> InternalStorageServiceAsyncClient::future_chainAddEdges(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::ChainAddEdgesRequest& p_req) { + folly::Promise< ::nebula::storage::cpp2::ExecResponse> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_chainAddEdges, channel_); + chainAddEdges(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::storage::cpp2::ExecResponse> InternalStorageServiceAsyncClient::semifuture_chainAddEdges(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::ChainAddEdgesRequest& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_chainAddEdges, channel_); + auto callback = std::move(callbackAndFuture.first); + chainAddEdges(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> InternalStorageServiceAsyncClient::header_future_chainAddEdges(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::ChainAddEdgesRequest& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_chainAddEdges, channel_); + chainAddEdges(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> InternalStorageServiceAsyncClient::header_semifuture_chainAddEdges(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::ChainAddEdgesRequest& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_chainAddEdges, channel_); + auto callback = std::move(callbackAndFuture.first); + chainAddEdges(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void InternalStorageServiceAsyncClient::chainAddEdges(folly::Function callback, const ::nebula::storage::cpp2::ChainAddEdgesRequest& p_req) { + chainAddEdges(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper InternalStorageServiceAsyncClient::recv_wrapped_chainAddEdges( ::nebula::storage::cpp2::ExecResponse& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = InternalStorageService_chainAddEdges_presult; + constexpr auto const fname = "chainAddEdges"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void InternalStorageServiceAsyncClient::recv_chainAddEdges( ::nebula::storage::cpp2::ExecResponse& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_chainAddEdges(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void InternalStorageServiceAsyncClient::recv_instance_chainAddEdges( ::nebula::storage::cpp2::ExecResponse& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_chainAddEdges(_return, state); +} + +folly::exception_wrapper InternalStorageServiceAsyncClient::recv_instance_wrapped_chainAddEdges( ::nebula::storage::cpp2::ExecResponse& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_chainAddEdges(_return, state); +} + +void InternalStorageServiceAsyncClient::chainUpdateEdge(std::unique_ptr callback, const ::nebula::storage::cpp2::ChainUpdateEdgeRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + chainUpdateEdge(rpcOptions, std::move(callback), p_req); +} + +void InternalStorageServiceAsyncClient::chainUpdateEdge(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::storage::cpp2::ChainUpdateEdgeRequest& p_req) { + auto ctx = chainUpdateEdgeCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + chainUpdateEdgeImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void InternalStorageServiceAsyncClient::chainUpdateEdgeImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::ChainUpdateEdgeRequest& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + chainUpdateEdgeT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + chainUpdateEdgeT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> InternalStorageServiceAsyncClient::chainUpdateEdgeCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "InternalStorageService.chainUpdateEdge"); +} + +void InternalStorageServiceAsyncClient::sync_chainUpdateEdge( ::nebula::storage::cpp2::UpdateResponse& _return, const ::nebula::storage::cpp2::ChainUpdateEdgeRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_chainUpdateEdge(rpcOptions, _return, p_req); +} + +void InternalStorageServiceAsyncClient::sync_chainUpdateEdge(apache::thrift::RpcOptions& rpcOptions, ::nebula::storage::cpp2::UpdateResponse& _return, const ::nebula::storage::cpp2::ChainUpdateEdgeRequest& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = chainUpdateEdgeCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + chainUpdateEdgeImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_chainUpdateEdge(_return, returnState); + }); +} + + +folly::Future< ::nebula::storage::cpp2::UpdateResponse> InternalStorageServiceAsyncClient::future_chainUpdateEdge(const ::nebula::storage::cpp2::ChainUpdateEdgeRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_chainUpdateEdge(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::storage::cpp2::UpdateResponse> InternalStorageServiceAsyncClient::semifuture_chainUpdateEdge(const ::nebula::storage::cpp2::ChainUpdateEdgeRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_chainUpdateEdge(rpcOptions, p_req); +} + +folly::Future< ::nebula::storage::cpp2::UpdateResponse> InternalStorageServiceAsyncClient::future_chainUpdateEdge(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::ChainUpdateEdgeRequest& p_req) { + folly::Promise< ::nebula::storage::cpp2::UpdateResponse> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_chainUpdateEdge, channel_); + chainUpdateEdge(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::storage::cpp2::UpdateResponse> InternalStorageServiceAsyncClient::semifuture_chainUpdateEdge(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::ChainUpdateEdgeRequest& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_chainUpdateEdge, channel_); + auto callback = std::move(callbackAndFuture.first); + chainUpdateEdge(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> InternalStorageServiceAsyncClient::header_future_chainUpdateEdge(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::ChainUpdateEdgeRequest& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_chainUpdateEdge, channel_); + chainUpdateEdge(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> InternalStorageServiceAsyncClient::header_semifuture_chainUpdateEdge(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::ChainUpdateEdgeRequest& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_chainUpdateEdge, channel_); + auto callback = std::move(callbackAndFuture.first); + chainUpdateEdge(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void InternalStorageServiceAsyncClient::chainUpdateEdge(folly::Function callback, const ::nebula::storage::cpp2::ChainUpdateEdgeRequest& p_req) { + chainUpdateEdge(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper InternalStorageServiceAsyncClient::recv_wrapped_chainUpdateEdge( ::nebula::storage::cpp2::UpdateResponse& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = InternalStorageService_chainUpdateEdge_presult; + constexpr auto const fname = "chainUpdateEdge"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void InternalStorageServiceAsyncClient::recv_chainUpdateEdge( ::nebula::storage::cpp2::UpdateResponse& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_chainUpdateEdge(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void InternalStorageServiceAsyncClient::recv_instance_chainUpdateEdge( ::nebula::storage::cpp2::UpdateResponse& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_chainUpdateEdge(_return, state); +} + +folly::exception_wrapper InternalStorageServiceAsyncClient::recv_instance_wrapped_chainUpdateEdge( ::nebula::storage::cpp2::UpdateResponse& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_chainUpdateEdge(_return, state); +} + + +}}} // nebula::storage::cpp2 diff --git a/src/interface/gen-cpp2/InternalStorageServiceAsyncClient.h b/src/interface/gen-cpp2/InternalStorageServiceAsyncClient.h new file mode 100644 index 00000000..7f2704ee --- /dev/null +++ b/src/interface/gen-cpp2/InternalStorageServiceAsyncClient.h @@ -0,0 +1,198 @@ +/** + * Autogenerated by Thrift for storage.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#pragma once + +#include + +#include "storage_types.h" +#include "common_types.h" +#include "meta_types.h" + +namespace apache { namespace thrift { + class Cpp2RequestContext; + namespace detail { namespace ac { struct ClientRequestContext; }} + namespace transport { class THeader; } +}} + +namespace nebula { namespace storage { namespace cpp2 { + +class InternalStorageServiceAsyncClient : public apache::thrift::GeneratedAsyncClient { + public: + using apache::thrift::GeneratedAsyncClient::GeneratedAsyncClient; + + char const* getServiceName() const noexcept override { + return "InternalStorageService"; + } + + + virtual void chainAddEdges(std::unique_ptr callback, const ::nebula::storage::cpp2::ChainAddEdgesRequest& p_req); + virtual void chainAddEdges(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::storage::cpp2::ChainAddEdgesRequest& p_req); + protected: + void chainAddEdgesImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::ChainAddEdgesRequest& p_req); + public: + + virtual void sync_chainAddEdges( ::nebula::storage::cpp2::ExecResponse& _return, const ::nebula::storage::cpp2::ChainAddEdgesRequest& p_req); + virtual void sync_chainAddEdges(apache::thrift::RpcOptions& rpcOptions, ::nebula::storage::cpp2::ExecResponse& _return, const ::nebula::storage::cpp2::ChainAddEdgesRequest& p_req); + + virtual folly::Future< ::nebula::storage::cpp2::ExecResponse> future_chainAddEdges(const ::nebula::storage::cpp2::ChainAddEdgesRequest& p_req); + virtual folly::SemiFuture< ::nebula::storage::cpp2::ExecResponse> semifuture_chainAddEdges(const ::nebula::storage::cpp2::ChainAddEdgesRequest& p_req); + virtual folly::Future< ::nebula::storage::cpp2::ExecResponse> future_chainAddEdges(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::ChainAddEdgesRequest& p_req); + virtual folly::SemiFuture< ::nebula::storage::cpp2::ExecResponse> semifuture_chainAddEdges(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::ChainAddEdgesRequest& p_req); + virtual folly::Future>> header_future_chainAddEdges(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::ChainAddEdgesRequest& p_req); + virtual folly::SemiFuture>> header_semifuture_chainAddEdges(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::ChainAddEdgesRequest& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::storage::cpp2::ExecResponse> co_chainAddEdges(const ::nebula::storage::cpp2::ChainAddEdgesRequest& p_req) { + return co_chainAddEdges(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::storage::cpp2::ExecResponse> co_chainAddEdges(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::ChainAddEdgesRequest& p_req) { + return co_chainAddEdges(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::storage::cpp2::ExecResponse> co_chainAddEdges(apache::thrift::RpcOptions* rpcOptions, const ::nebula::storage::cpp2::ChainAddEdgesRequest& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = chainAddEdgesCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + chainAddEdgesImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + chainAddEdgesImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::storage::cpp2::ExecResponse _return; + if (auto ew = recv_wrapped_chainAddEdges(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void chainAddEdges(folly::Function callback, const ::nebula::storage::cpp2::ChainAddEdgesRequest& p_req); + + + static folly::exception_wrapper recv_wrapped_chainAddEdges( ::nebula::storage::cpp2::ExecResponse& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_chainAddEdges( ::nebula::storage::cpp2::ExecResponse& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_chainAddEdges( ::nebula::storage::cpp2::ExecResponse& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_chainAddEdges( ::nebula::storage::cpp2::ExecResponse& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void chainAddEdgesT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::ChainAddEdgesRequest& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> chainAddEdgesCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void chainUpdateEdge(std::unique_ptr callback, const ::nebula::storage::cpp2::ChainUpdateEdgeRequest& p_req); + virtual void chainUpdateEdge(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::storage::cpp2::ChainUpdateEdgeRequest& p_req); + protected: + void chainUpdateEdgeImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::ChainUpdateEdgeRequest& p_req); + public: + + virtual void sync_chainUpdateEdge( ::nebula::storage::cpp2::UpdateResponse& _return, const ::nebula::storage::cpp2::ChainUpdateEdgeRequest& p_req); + virtual void sync_chainUpdateEdge(apache::thrift::RpcOptions& rpcOptions, ::nebula::storage::cpp2::UpdateResponse& _return, const ::nebula::storage::cpp2::ChainUpdateEdgeRequest& p_req); + + virtual folly::Future< ::nebula::storage::cpp2::UpdateResponse> future_chainUpdateEdge(const ::nebula::storage::cpp2::ChainUpdateEdgeRequest& p_req); + virtual folly::SemiFuture< ::nebula::storage::cpp2::UpdateResponse> semifuture_chainUpdateEdge(const ::nebula::storage::cpp2::ChainUpdateEdgeRequest& p_req); + virtual folly::Future< ::nebula::storage::cpp2::UpdateResponse> future_chainUpdateEdge(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::ChainUpdateEdgeRequest& p_req); + virtual folly::SemiFuture< ::nebula::storage::cpp2::UpdateResponse> semifuture_chainUpdateEdge(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::ChainUpdateEdgeRequest& p_req); + virtual folly::Future>> header_future_chainUpdateEdge(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::ChainUpdateEdgeRequest& p_req); + virtual folly::SemiFuture>> header_semifuture_chainUpdateEdge(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::ChainUpdateEdgeRequest& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::storage::cpp2::UpdateResponse> co_chainUpdateEdge(const ::nebula::storage::cpp2::ChainUpdateEdgeRequest& p_req) { + return co_chainUpdateEdge(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::storage::cpp2::UpdateResponse> co_chainUpdateEdge(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::ChainUpdateEdgeRequest& p_req) { + return co_chainUpdateEdge(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::storage::cpp2::UpdateResponse> co_chainUpdateEdge(apache::thrift::RpcOptions* rpcOptions, const ::nebula::storage::cpp2::ChainUpdateEdgeRequest& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = chainUpdateEdgeCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + chainUpdateEdgeImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + chainUpdateEdgeImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::storage::cpp2::UpdateResponse _return; + if (auto ew = recv_wrapped_chainUpdateEdge(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void chainUpdateEdge(folly::Function callback, const ::nebula::storage::cpp2::ChainUpdateEdgeRequest& p_req); + + + static folly::exception_wrapper recv_wrapped_chainUpdateEdge( ::nebula::storage::cpp2::UpdateResponse& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_chainUpdateEdge( ::nebula::storage::cpp2::UpdateResponse& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_chainUpdateEdge( ::nebula::storage::cpp2::UpdateResponse& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_chainUpdateEdge( ::nebula::storage::cpp2::UpdateResponse& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void chainUpdateEdgeT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::ChainUpdateEdgeRequest& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> chainUpdateEdgeCtx(apache::thrift::RpcOptions* rpcOptions); + public: +}; + +}}} // nebula::storage::cpp2 diff --git a/src/interface/gen-cpp2/InternalStorageService_custom_protocol.h b/src/interface/gen-cpp2/InternalStorageService_custom_protocol.h new file mode 100644 index 00000000..0e534f93 --- /dev/null +++ b/src/interface/gen-cpp2/InternalStorageService_custom_protocol.h @@ -0,0 +1,19 @@ +/** + * Autogenerated by Thrift for storage.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#pragma once + +/** + * This header file includes the tcc files of the corresponding header file + * and the header files of its dependent types. Include this header file + * only when you need to use custom protocols (e.g. DebugProtocol, + * VirtualProtocol) to read/write thrift structs. + */ + +#include "InternalStorageService.tcc" +#include "storage_types_custom_protocol.h" +#include "common_types_custom_protocol.h" +#include "meta_types_custom_protocol.h" diff --git a/src/interface/gen-cpp2/InternalStorageService_processmap_binary.cpp b/src/interface/gen-cpp2/InternalStorageService_processmap_binary.cpp new file mode 100644 index 00000000..c597c0e0 --- /dev/null +++ b/src/interface/gen-cpp2/InternalStorageService_processmap_binary.cpp @@ -0,0 +1,12 @@ +/** + * Autogenerated by Thrift for storage.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ + +#include "InternalStorageService.h" +#include "InternalStorageService.tcc" + +namespace nebula { namespace storage { namespace cpp2 { +}}} // nebula::storage::cpp2 diff --git a/src/interface/gen-cpp2/InternalStorageService_processmap_compact.cpp b/src/interface/gen-cpp2/InternalStorageService_processmap_compact.cpp new file mode 100644 index 00000000..c597c0e0 --- /dev/null +++ b/src/interface/gen-cpp2/InternalStorageService_processmap_compact.cpp @@ -0,0 +1,12 @@ +/** + * Autogenerated by Thrift for storage.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ + +#include "InternalStorageService.h" +#include "InternalStorageService.tcc" + +namespace nebula { namespace storage { namespace cpp2 { +}}} // nebula::storage::cpp2 diff --git a/src/interface/gen-cpp2/MetaService.cpp b/src/interface/gen-cpp2/MetaService.cpp new file mode 100644 index 00000000..a3deb368 --- /dev/null +++ b/src/interface/gen-cpp2/MetaService.cpp @@ -0,0 +1,2300 @@ +/** + * Autogenerated by Thrift for meta.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#include "MetaService.h" +#include "MetaService.tcc" +#include "meta_metadata.h" +#include + +namespace nebula { namespace meta { namespace cpp2 { +std::unique_ptr MetaServiceSvIf::getProcessor() { + return std::make_unique(this); +} + + +void MetaServiceSvIf::createSpace( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::CreateSpaceReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("createSpace"); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceSvIf::semifuture_createSpace(const ::nebula::meta::cpp2::CreateSpaceReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::meta::cpp2::ExecResp& _return) { createSpace(_return, p_req); }); +} + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceSvIf::future_createSpace(const ::nebula::meta::cpp2::CreateSpaceReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_createSpace(p_req), std::move(ka)); +} + +void MetaServiceSvIf::async_tm_createSpace(std::unique_ptr> callback, const ::nebula::meta::cpp2::CreateSpaceReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_createSpace(p_req); + }); +} + +void MetaServiceSvIf::dropSpace( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::DropSpaceReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("dropSpace"); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceSvIf::semifuture_dropSpace(const ::nebula::meta::cpp2::DropSpaceReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::meta::cpp2::ExecResp& _return) { dropSpace(_return, p_req); }); +} + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceSvIf::future_dropSpace(const ::nebula::meta::cpp2::DropSpaceReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_dropSpace(p_req), std::move(ka)); +} + +void MetaServiceSvIf::async_tm_dropSpace(std::unique_ptr> callback, const ::nebula::meta::cpp2::DropSpaceReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_dropSpace(p_req); + }); +} + +void MetaServiceSvIf::getSpace( ::nebula::meta::cpp2::GetSpaceResp& /*_return*/, const ::nebula::meta::cpp2::GetSpaceReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("getSpace"); +} + +folly::SemiFuture< ::nebula::meta::cpp2::GetSpaceResp> MetaServiceSvIf::semifuture_getSpace(const ::nebula::meta::cpp2::GetSpaceReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::meta::cpp2::GetSpaceResp& _return) { getSpace(_return, p_req); }); +} + +folly::Future< ::nebula::meta::cpp2::GetSpaceResp> MetaServiceSvIf::future_getSpace(const ::nebula::meta::cpp2::GetSpaceReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_getSpace(p_req), std::move(ka)); +} + +void MetaServiceSvIf::async_tm_getSpace(std::unique_ptr> callback, const ::nebula::meta::cpp2::GetSpaceReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_getSpace(p_req); + }); +} + +void MetaServiceSvIf::listSpaces( ::nebula::meta::cpp2::ListSpacesResp& /*_return*/, const ::nebula::meta::cpp2::ListSpacesReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("listSpaces"); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ListSpacesResp> MetaServiceSvIf::semifuture_listSpaces(const ::nebula::meta::cpp2::ListSpacesReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::meta::cpp2::ListSpacesResp& _return) { listSpaces(_return, p_req); }); +} + +folly::Future< ::nebula::meta::cpp2::ListSpacesResp> MetaServiceSvIf::future_listSpaces(const ::nebula::meta::cpp2::ListSpacesReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_listSpaces(p_req), std::move(ka)); +} + +void MetaServiceSvIf::async_tm_listSpaces(std::unique_ptr> callback, const ::nebula::meta::cpp2::ListSpacesReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_listSpaces(p_req); + }); +} + +void MetaServiceSvIf::createSpaceAs( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::CreateSpaceAsReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("createSpaceAs"); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceSvIf::semifuture_createSpaceAs(const ::nebula::meta::cpp2::CreateSpaceAsReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::meta::cpp2::ExecResp& _return) { createSpaceAs(_return, p_req); }); +} + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceSvIf::future_createSpaceAs(const ::nebula::meta::cpp2::CreateSpaceAsReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_createSpaceAs(p_req), std::move(ka)); +} + +void MetaServiceSvIf::async_tm_createSpaceAs(std::unique_ptr> callback, const ::nebula::meta::cpp2::CreateSpaceAsReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_createSpaceAs(p_req); + }); +} + +void MetaServiceSvIf::createTag( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::CreateTagReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("createTag"); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceSvIf::semifuture_createTag(const ::nebula::meta::cpp2::CreateTagReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::meta::cpp2::ExecResp& _return) { createTag(_return, p_req); }); +} + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceSvIf::future_createTag(const ::nebula::meta::cpp2::CreateTagReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_createTag(p_req), std::move(ka)); +} + +void MetaServiceSvIf::async_tm_createTag(std::unique_ptr> callback, const ::nebula::meta::cpp2::CreateTagReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_createTag(p_req); + }); +} + +void MetaServiceSvIf::alterTag( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::AlterTagReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("alterTag"); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceSvIf::semifuture_alterTag(const ::nebula::meta::cpp2::AlterTagReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::meta::cpp2::ExecResp& _return) { alterTag(_return, p_req); }); +} + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceSvIf::future_alterTag(const ::nebula::meta::cpp2::AlterTagReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_alterTag(p_req), std::move(ka)); +} + +void MetaServiceSvIf::async_tm_alterTag(std::unique_ptr> callback, const ::nebula::meta::cpp2::AlterTagReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_alterTag(p_req); + }); +} + +void MetaServiceSvIf::dropTag( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::DropTagReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("dropTag"); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceSvIf::semifuture_dropTag(const ::nebula::meta::cpp2::DropTagReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::meta::cpp2::ExecResp& _return) { dropTag(_return, p_req); }); +} + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceSvIf::future_dropTag(const ::nebula::meta::cpp2::DropTagReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_dropTag(p_req), std::move(ka)); +} + +void MetaServiceSvIf::async_tm_dropTag(std::unique_ptr> callback, const ::nebula::meta::cpp2::DropTagReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_dropTag(p_req); + }); +} + +void MetaServiceSvIf::getTag( ::nebula::meta::cpp2::GetTagResp& /*_return*/, const ::nebula::meta::cpp2::GetTagReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("getTag"); +} + +folly::SemiFuture< ::nebula::meta::cpp2::GetTagResp> MetaServiceSvIf::semifuture_getTag(const ::nebula::meta::cpp2::GetTagReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::meta::cpp2::GetTagResp& _return) { getTag(_return, p_req); }); +} + +folly::Future< ::nebula::meta::cpp2::GetTagResp> MetaServiceSvIf::future_getTag(const ::nebula::meta::cpp2::GetTagReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_getTag(p_req), std::move(ka)); +} + +void MetaServiceSvIf::async_tm_getTag(std::unique_ptr> callback, const ::nebula::meta::cpp2::GetTagReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_getTag(p_req); + }); +} + +void MetaServiceSvIf::listTags( ::nebula::meta::cpp2::ListTagsResp& /*_return*/, const ::nebula::meta::cpp2::ListTagsReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("listTags"); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ListTagsResp> MetaServiceSvIf::semifuture_listTags(const ::nebula::meta::cpp2::ListTagsReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::meta::cpp2::ListTagsResp& _return) { listTags(_return, p_req); }); +} + +folly::Future< ::nebula::meta::cpp2::ListTagsResp> MetaServiceSvIf::future_listTags(const ::nebula::meta::cpp2::ListTagsReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_listTags(p_req), std::move(ka)); +} + +void MetaServiceSvIf::async_tm_listTags(std::unique_ptr> callback, const ::nebula::meta::cpp2::ListTagsReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_listTags(p_req); + }); +} + +void MetaServiceSvIf::createEdge( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::CreateEdgeReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("createEdge"); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceSvIf::semifuture_createEdge(const ::nebula::meta::cpp2::CreateEdgeReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::meta::cpp2::ExecResp& _return) { createEdge(_return, p_req); }); +} + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceSvIf::future_createEdge(const ::nebula::meta::cpp2::CreateEdgeReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_createEdge(p_req), std::move(ka)); +} + +void MetaServiceSvIf::async_tm_createEdge(std::unique_ptr> callback, const ::nebula::meta::cpp2::CreateEdgeReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_createEdge(p_req); + }); +} + +void MetaServiceSvIf::alterEdge( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::AlterEdgeReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("alterEdge"); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceSvIf::semifuture_alterEdge(const ::nebula::meta::cpp2::AlterEdgeReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::meta::cpp2::ExecResp& _return) { alterEdge(_return, p_req); }); +} + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceSvIf::future_alterEdge(const ::nebula::meta::cpp2::AlterEdgeReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_alterEdge(p_req), std::move(ka)); +} + +void MetaServiceSvIf::async_tm_alterEdge(std::unique_ptr> callback, const ::nebula::meta::cpp2::AlterEdgeReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_alterEdge(p_req); + }); +} + +void MetaServiceSvIf::dropEdge( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::DropEdgeReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("dropEdge"); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceSvIf::semifuture_dropEdge(const ::nebula::meta::cpp2::DropEdgeReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::meta::cpp2::ExecResp& _return) { dropEdge(_return, p_req); }); +} + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceSvIf::future_dropEdge(const ::nebula::meta::cpp2::DropEdgeReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_dropEdge(p_req), std::move(ka)); +} + +void MetaServiceSvIf::async_tm_dropEdge(std::unique_ptr> callback, const ::nebula::meta::cpp2::DropEdgeReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_dropEdge(p_req); + }); +} + +void MetaServiceSvIf::getEdge( ::nebula::meta::cpp2::GetEdgeResp& /*_return*/, const ::nebula::meta::cpp2::GetEdgeReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("getEdge"); +} + +folly::SemiFuture< ::nebula::meta::cpp2::GetEdgeResp> MetaServiceSvIf::semifuture_getEdge(const ::nebula::meta::cpp2::GetEdgeReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::meta::cpp2::GetEdgeResp& _return) { getEdge(_return, p_req); }); +} + +folly::Future< ::nebula::meta::cpp2::GetEdgeResp> MetaServiceSvIf::future_getEdge(const ::nebula::meta::cpp2::GetEdgeReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_getEdge(p_req), std::move(ka)); +} + +void MetaServiceSvIf::async_tm_getEdge(std::unique_ptr> callback, const ::nebula::meta::cpp2::GetEdgeReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_getEdge(p_req); + }); +} + +void MetaServiceSvIf::listEdges( ::nebula::meta::cpp2::ListEdgesResp& /*_return*/, const ::nebula::meta::cpp2::ListEdgesReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("listEdges"); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ListEdgesResp> MetaServiceSvIf::semifuture_listEdges(const ::nebula::meta::cpp2::ListEdgesReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::meta::cpp2::ListEdgesResp& _return) { listEdges(_return, p_req); }); +} + +folly::Future< ::nebula::meta::cpp2::ListEdgesResp> MetaServiceSvIf::future_listEdges(const ::nebula::meta::cpp2::ListEdgesReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_listEdges(p_req), std::move(ka)); +} + +void MetaServiceSvIf::async_tm_listEdges(std::unique_ptr> callback, const ::nebula::meta::cpp2::ListEdgesReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_listEdges(p_req); + }); +} + +void MetaServiceSvIf::listHosts( ::nebula::meta::cpp2::ListHostsResp& /*_return*/, const ::nebula::meta::cpp2::ListHostsReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("listHosts"); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ListHostsResp> MetaServiceSvIf::semifuture_listHosts(const ::nebula::meta::cpp2::ListHostsReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::meta::cpp2::ListHostsResp& _return) { listHosts(_return, p_req); }); +} + +folly::Future< ::nebula::meta::cpp2::ListHostsResp> MetaServiceSvIf::future_listHosts(const ::nebula::meta::cpp2::ListHostsReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_listHosts(p_req), std::move(ka)); +} + +void MetaServiceSvIf::async_tm_listHosts(std::unique_ptr> callback, const ::nebula::meta::cpp2::ListHostsReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_listHosts(p_req); + }); +} + +void MetaServiceSvIf::getPartsAlloc( ::nebula::meta::cpp2::GetPartsAllocResp& /*_return*/, const ::nebula::meta::cpp2::GetPartsAllocReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("getPartsAlloc"); +} + +folly::SemiFuture< ::nebula::meta::cpp2::GetPartsAllocResp> MetaServiceSvIf::semifuture_getPartsAlloc(const ::nebula::meta::cpp2::GetPartsAllocReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::meta::cpp2::GetPartsAllocResp& _return) { getPartsAlloc(_return, p_req); }); +} + +folly::Future< ::nebula::meta::cpp2::GetPartsAllocResp> MetaServiceSvIf::future_getPartsAlloc(const ::nebula::meta::cpp2::GetPartsAllocReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_getPartsAlloc(p_req), std::move(ka)); +} + +void MetaServiceSvIf::async_tm_getPartsAlloc(std::unique_ptr> callback, const ::nebula::meta::cpp2::GetPartsAllocReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_getPartsAlloc(p_req); + }); +} + +void MetaServiceSvIf::listParts( ::nebula::meta::cpp2::ListPartsResp& /*_return*/, const ::nebula::meta::cpp2::ListPartsReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("listParts"); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ListPartsResp> MetaServiceSvIf::semifuture_listParts(const ::nebula::meta::cpp2::ListPartsReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::meta::cpp2::ListPartsResp& _return) { listParts(_return, p_req); }); +} + +folly::Future< ::nebula::meta::cpp2::ListPartsResp> MetaServiceSvIf::future_listParts(const ::nebula::meta::cpp2::ListPartsReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_listParts(p_req), std::move(ka)); +} + +void MetaServiceSvIf::async_tm_listParts(std::unique_ptr> callback, const ::nebula::meta::cpp2::ListPartsReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_listParts(p_req); + }); +} + +void MetaServiceSvIf::multiPut( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::MultiPutReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("multiPut"); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceSvIf::semifuture_multiPut(const ::nebula::meta::cpp2::MultiPutReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::meta::cpp2::ExecResp& _return) { multiPut(_return, p_req); }); +} + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceSvIf::future_multiPut(const ::nebula::meta::cpp2::MultiPutReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_multiPut(p_req), std::move(ka)); +} + +void MetaServiceSvIf::async_tm_multiPut(std::unique_ptr> callback, const ::nebula::meta::cpp2::MultiPutReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_multiPut(p_req); + }); +} + +void MetaServiceSvIf::get( ::nebula::meta::cpp2::GetResp& /*_return*/, const ::nebula::meta::cpp2::GetReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("get"); +} + +folly::SemiFuture< ::nebula::meta::cpp2::GetResp> MetaServiceSvIf::semifuture_get(const ::nebula::meta::cpp2::GetReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::meta::cpp2::GetResp& _return) { get(_return, p_req); }); +} + +folly::Future< ::nebula::meta::cpp2::GetResp> MetaServiceSvIf::future_get(const ::nebula::meta::cpp2::GetReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_get(p_req), std::move(ka)); +} + +void MetaServiceSvIf::async_tm_get(std::unique_ptr> callback, const ::nebula::meta::cpp2::GetReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_get(p_req); + }); +} + +void MetaServiceSvIf::multiGet( ::nebula::meta::cpp2::MultiGetResp& /*_return*/, const ::nebula::meta::cpp2::MultiGetReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("multiGet"); +} + +folly::SemiFuture< ::nebula::meta::cpp2::MultiGetResp> MetaServiceSvIf::semifuture_multiGet(const ::nebula::meta::cpp2::MultiGetReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::meta::cpp2::MultiGetResp& _return) { multiGet(_return, p_req); }); +} + +folly::Future< ::nebula::meta::cpp2::MultiGetResp> MetaServiceSvIf::future_multiGet(const ::nebula::meta::cpp2::MultiGetReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_multiGet(p_req), std::move(ka)); +} + +void MetaServiceSvIf::async_tm_multiGet(std::unique_ptr> callback, const ::nebula::meta::cpp2::MultiGetReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_multiGet(p_req); + }); +} + +void MetaServiceSvIf::remove( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::RemoveReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("remove"); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceSvIf::semifuture_remove(const ::nebula::meta::cpp2::RemoveReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::meta::cpp2::ExecResp& _return) { remove(_return, p_req); }); +} + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceSvIf::future_remove(const ::nebula::meta::cpp2::RemoveReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_remove(p_req), std::move(ka)); +} + +void MetaServiceSvIf::async_tm_remove(std::unique_ptr> callback, const ::nebula::meta::cpp2::RemoveReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_remove(p_req); + }); +} + +void MetaServiceSvIf::removeRange( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::RemoveRangeReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("removeRange"); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceSvIf::semifuture_removeRange(const ::nebula::meta::cpp2::RemoveRangeReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::meta::cpp2::ExecResp& _return) { removeRange(_return, p_req); }); +} + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceSvIf::future_removeRange(const ::nebula::meta::cpp2::RemoveRangeReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_removeRange(p_req), std::move(ka)); +} + +void MetaServiceSvIf::async_tm_removeRange(std::unique_ptr> callback, const ::nebula::meta::cpp2::RemoveRangeReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_removeRange(p_req); + }); +} + +void MetaServiceSvIf::scan( ::nebula::meta::cpp2::ScanResp& /*_return*/, const ::nebula::meta::cpp2::ScanReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("scan"); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ScanResp> MetaServiceSvIf::semifuture_scan(const ::nebula::meta::cpp2::ScanReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::meta::cpp2::ScanResp& _return) { scan(_return, p_req); }); +} + +folly::Future< ::nebula::meta::cpp2::ScanResp> MetaServiceSvIf::future_scan(const ::nebula::meta::cpp2::ScanReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_scan(p_req), std::move(ka)); +} + +void MetaServiceSvIf::async_tm_scan(std::unique_ptr> callback, const ::nebula::meta::cpp2::ScanReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_scan(p_req); + }); +} + +void MetaServiceSvIf::createTagIndex( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::CreateTagIndexReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("createTagIndex"); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceSvIf::semifuture_createTagIndex(const ::nebula::meta::cpp2::CreateTagIndexReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::meta::cpp2::ExecResp& _return) { createTagIndex(_return, p_req); }); +} + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceSvIf::future_createTagIndex(const ::nebula::meta::cpp2::CreateTagIndexReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_createTagIndex(p_req), std::move(ka)); +} + +void MetaServiceSvIf::async_tm_createTagIndex(std::unique_ptr> callback, const ::nebula::meta::cpp2::CreateTagIndexReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_createTagIndex(p_req); + }); +} + +void MetaServiceSvIf::dropTagIndex( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::DropTagIndexReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("dropTagIndex"); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceSvIf::semifuture_dropTagIndex(const ::nebula::meta::cpp2::DropTagIndexReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::meta::cpp2::ExecResp& _return) { dropTagIndex(_return, p_req); }); +} + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceSvIf::future_dropTagIndex(const ::nebula::meta::cpp2::DropTagIndexReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_dropTagIndex(p_req), std::move(ka)); +} + +void MetaServiceSvIf::async_tm_dropTagIndex(std::unique_ptr> callback, const ::nebula::meta::cpp2::DropTagIndexReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_dropTagIndex(p_req); + }); +} + +void MetaServiceSvIf::getTagIndex( ::nebula::meta::cpp2::GetTagIndexResp& /*_return*/, const ::nebula::meta::cpp2::GetTagIndexReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("getTagIndex"); +} + +folly::SemiFuture< ::nebula::meta::cpp2::GetTagIndexResp> MetaServiceSvIf::semifuture_getTagIndex(const ::nebula::meta::cpp2::GetTagIndexReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::meta::cpp2::GetTagIndexResp& _return) { getTagIndex(_return, p_req); }); +} + +folly::Future< ::nebula::meta::cpp2::GetTagIndexResp> MetaServiceSvIf::future_getTagIndex(const ::nebula::meta::cpp2::GetTagIndexReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_getTagIndex(p_req), std::move(ka)); +} + +void MetaServiceSvIf::async_tm_getTagIndex(std::unique_ptr> callback, const ::nebula::meta::cpp2::GetTagIndexReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_getTagIndex(p_req); + }); +} + +void MetaServiceSvIf::listTagIndexes( ::nebula::meta::cpp2::ListTagIndexesResp& /*_return*/, const ::nebula::meta::cpp2::ListTagIndexesReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("listTagIndexes"); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ListTagIndexesResp> MetaServiceSvIf::semifuture_listTagIndexes(const ::nebula::meta::cpp2::ListTagIndexesReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::meta::cpp2::ListTagIndexesResp& _return) { listTagIndexes(_return, p_req); }); +} + +folly::Future< ::nebula::meta::cpp2::ListTagIndexesResp> MetaServiceSvIf::future_listTagIndexes(const ::nebula::meta::cpp2::ListTagIndexesReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_listTagIndexes(p_req), std::move(ka)); +} + +void MetaServiceSvIf::async_tm_listTagIndexes(std::unique_ptr> callback, const ::nebula::meta::cpp2::ListTagIndexesReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_listTagIndexes(p_req); + }); +} + +void MetaServiceSvIf::rebuildTagIndex( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::RebuildIndexReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("rebuildTagIndex"); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceSvIf::semifuture_rebuildTagIndex(const ::nebula::meta::cpp2::RebuildIndexReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::meta::cpp2::ExecResp& _return) { rebuildTagIndex(_return, p_req); }); +} + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceSvIf::future_rebuildTagIndex(const ::nebula::meta::cpp2::RebuildIndexReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_rebuildTagIndex(p_req), std::move(ka)); +} + +void MetaServiceSvIf::async_tm_rebuildTagIndex(std::unique_ptr> callback, const ::nebula::meta::cpp2::RebuildIndexReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_rebuildTagIndex(p_req); + }); +} + +void MetaServiceSvIf::listTagIndexStatus( ::nebula::meta::cpp2::ListIndexStatusResp& /*_return*/, const ::nebula::meta::cpp2::ListIndexStatusReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("listTagIndexStatus"); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ListIndexStatusResp> MetaServiceSvIf::semifuture_listTagIndexStatus(const ::nebula::meta::cpp2::ListIndexStatusReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::meta::cpp2::ListIndexStatusResp& _return) { listTagIndexStatus(_return, p_req); }); +} + +folly::Future< ::nebula::meta::cpp2::ListIndexStatusResp> MetaServiceSvIf::future_listTagIndexStatus(const ::nebula::meta::cpp2::ListIndexStatusReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_listTagIndexStatus(p_req), std::move(ka)); +} + +void MetaServiceSvIf::async_tm_listTagIndexStatus(std::unique_ptr> callback, const ::nebula::meta::cpp2::ListIndexStatusReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_listTagIndexStatus(p_req); + }); +} + +void MetaServiceSvIf::createEdgeIndex( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::CreateEdgeIndexReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("createEdgeIndex"); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceSvIf::semifuture_createEdgeIndex(const ::nebula::meta::cpp2::CreateEdgeIndexReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::meta::cpp2::ExecResp& _return) { createEdgeIndex(_return, p_req); }); +} + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceSvIf::future_createEdgeIndex(const ::nebula::meta::cpp2::CreateEdgeIndexReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_createEdgeIndex(p_req), std::move(ka)); +} + +void MetaServiceSvIf::async_tm_createEdgeIndex(std::unique_ptr> callback, const ::nebula::meta::cpp2::CreateEdgeIndexReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_createEdgeIndex(p_req); + }); +} + +void MetaServiceSvIf::dropEdgeIndex( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::DropEdgeIndexReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("dropEdgeIndex"); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceSvIf::semifuture_dropEdgeIndex(const ::nebula::meta::cpp2::DropEdgeIndexReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::meta::cpp2::ExecResp& _return) { dropEdgeIndex(_return, p_req); }); +} + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceSvIf::future_dropEdgeIndex(const ::nebula::meta::cpp2::DropEdgeIndexReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_dropEdgeIndex(p_req), std::move(ka)); +} + +void MetaServiceSvIf::async_tm_dropEdgeIndex(std::unique_ptr> callback, const ::nebula::meta::cpp2::DropEdgeIndexReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_dropEdgeIndex(p_req); + }); +} + +void MetaServiceSvIf::getEdgeIndex( ::nebula::meta::cpp2::GetEdgeIndexResp& /*_return*/, const ::nebula::meta::cpp2::GetEdgeIndexReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("getEdgeIndex"); +} + +folly::SemiFuture< ::nebula::meta::cpp2::GetEdgeIndexResp> MetaServiceSvIf::semifuture_getEdgeIndex(const ::nebula::meta::cpp2::GetEdgeIndexReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::meta::cpp2::GetEdgeIndexResp& _return) { getEdgeIndex(_return, p_req); }); +} + +folly::Future< ::nebula::meta::cpp2::GetEdgeIndexResp> MetaServiceSvIf::future_getEdgeIndex(const ::nebula::meta::cpp2::GetEdgeIndexReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_getEdgeIndex(p_req), std::move(ka)); +} + +void MetaServiceSvIf::async_tm_getEdgeIndex(std::unique_ptr> callback, const ::nebula::meta::cpp2::GetEdgeIndexReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_getEdgeIndex(p_req); + }); +} + +void MetaServiceSvIf::listEdgeIndexes( ::nebula::meta::cpp2::ListEdgeIndexesResp& /*_return*/, const ::nebula::meta::cpp2::ListEdgeIndexesReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("listEdgeIndexes"); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ListEdgeIndexesResp> MetaServiceSvIf::semifuture_listEdgeIndexes(const ::nebula::meta::cpp2::ListEdgeIndexesReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::meta::cpp2::ListEdgeIndexesResp& _return) { listEdgeIndexes(_return, p_req); }); +} + +folly::Future< ::nebula::meta::cpp2::ListEdgeIndexesResp> MetaServiceSvIf::future_listEdgeIndexes(const ::nebula::meta::cpp2::ListEdgeIndexesReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_listEdgeIndexes(p_req), std::move(ka)); +} + +void MetaServiceSvIf::async_tm_listEdgeIndexes(std::unique_ptr> callback, const ::nebula::meta::cpp2::ListEdgeIndexesReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_listEdgeIndexes(p_req); + }); +} + +void MetaServiceSvIf::rebuildEdgeIndex( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::RebuildIndexReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("rebuildEdgeIndex"); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceSvIf::semifuture_rebuildEdgeIndex(const ::nebula::meta::cpp2::RebuildIndexReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::meta::cpp2::ExecResp& _return) { rebuildEdgeIndex(_return, p_req); }); +} + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceSvIf::future_rebuildEdgeIndex(const ::nebula::meta::cpp2::RebuildIndexReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_rebuildEdgeIndex(p_req), std::move(ka)); +} + +void MetaServiceSvIf::async_tm_rebuildEdgeIndex(std::unique_ptr> callback, const ::nebula::meta::cpp2::RebuildIndexReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_rebuildEdgeIndex(p_req); + }); +} + +void MetaServiceSvIf::listEdgeIndexStatus( ::nebula::meta::cpp2::ListIndexStatusResp& /*_return*/, const ::nebula::meta::cpp2::ListIndexStatusReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("listEdgeIndexStatus"); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ListIndexStatusResp> MetaServiceSvIf::semifuture_listEdgeIndexStatus(const ::nebula::meta::cpp2::ListIndexStatusReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::meta::cpp2::ListIndexStatusResp& _return) { listEdgeIndexStatus(_return, p_req); }); +} + +folly::Future< ::nebula::meta::cpp2::ListIndexStatusResp> MetaServiceSvIf::future_listEdgeIndexStatus(const ::nebula::meta::cpp2::ListIndexStatusReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_listEdgeIndexStatus(p_req), std::move(ka)); +} + +void MetaServiceSvIf::async_tm_listEdgeIndexStatus(std::unique_ptr> callback, const ::nebula::meta::cpp2::ListIndexStatusReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_listEdgeIndexStatus(p_req); + }); +} + +void MetaServiceSvIf::createUser( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::CreateUserReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("createUser"); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceSvIf::semifuture_createUser(const ::nebula::meta::cpp2::CreateUserReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::meta::cpp2::ExecResp& _return) { createUser(_return, p_req); }); +} + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceSvIf::future_createUser(const ::nebula::meta::cpp2::CreateUserReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_createUser(p_req), std::move(ka)); +} + +void MetaServiceSvIf::async_tm_createUser(std::unique_ptr> callback, const ::nebula::meta::cpp2::CreateUserReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_createUser(p_req); + }); +} + +void MetaServiceSvIf::dropUser( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::DropUserReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("dropUser"); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceSvIf::semifuture_dropUser(const ::nebula::meta::cpp2::DropUserReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::meta::cpp2::ExecResp& _return) { dropUser(_return, p_req); }); +} + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceSvIf::future_dropUser(const ::nebula::meta::cpp2::DropUserReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_dropUser(p_req), std::move(ka)); +} + +void MetaServiceSvIf::async_tm_dropUser(std::unique_ptr> callback, const ::nebula::meta::cpp2::DropUserReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_dropUser(p_req); + }); +} + +void MetaServiceSvIf::alterUser( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::AlterUserReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("alterUser"); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceSvIf::semifuture_alterUser(const ::nebula::meta::cpp2::AlterUserReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::meta::cpp2::ExecResp& _return) { alterUser(_return, p_req); }); +} + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceSvIf::future_alterUser(const ::nebula::meta::cpp2::AlterUserReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_alterUser(p_req), std::move(ka)); +} + +void MetaServiceSvIf::async_tm_alterUser(std::unique_ptr> callback, const ::nebula::meta::cpp2::AlterUserReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_alterUser(p_req); + }); +} + +void MetaServiceSvIf::grantRole( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::GrantRoleReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("grantRole"); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceSvIf::semifuture_grantRole(const ::nebula::meta::cpp2::GrantRoleReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::meta::cpp2::ExecResp& _return) { grantRole(_return, p_req); }); +} + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceSvIf::future_grantRole(const ::nebula::meta::cpp2::GrantRoleReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_grantRole(p_req), std::move(ka)); +} + +void MetaServiceSvIf::async_tm_grantRole(std::unique_ptr> callback, const ::nebula::meta::cpp2::GrantRoleReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_grantRole(p_req); + }); +} + +void MetaServiceSvIf::revokeRole( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::RevokeRoleReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("revokeRole"); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceSvIf::semifuture_revokeRole(const ::nebula::meta::cpp2::RevokeRoleReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::meta::cpp2::ExecResp& _return) { revokeRole(_return, p_req); }); +} + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceSvIf::future_revokeRole(const ::nebula::meta::cpp2::RevokeRoleReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_revokeRole(p_req), std::move(ka)); +} + +void MetaServiceSvIf::async_tm_revokeRole(std::unique_ptr> callback, const ::nebula::meta::cpp2::RevokeRoleReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_revokeRole(p_req); + }); +} + +void MetaServiceSvIf::listUsers( ::nebula::meta::cpp2::ListUsersResp& /*_return*/, const ::nebula::meta::cpp2::ListUsersReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("listUsers"); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ListUsersResp> MetaServiceSvIf::semifuture_listUsers(const ::nebula::meta::cpp2::ListUsersReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::meta::cpp2::ListUsersResp& _return) { listUsers(_return, p_req); }); +} + +folly::Future< ::nebula::meta::cpp2::ListUsersResp> MetaServiceSvIf::future_listUsers(const ::nebula::meta::cpp2::ListUsersReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_listUsers(p_req), std::move(ka)); +} + +void MetaServiceSvIf::async_tm_listUsers(std::unique_ptr> callback, const ::nebula::meta::cpp2::ListUsersReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_listUsers(p_req); + }); +} + +void MetaServiceSvIf::listRoles( ::nebula::meta::cpp2::ListRolesResp& /*_return*/, const ::nebula::meta::cpp2::ListRolesReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("listRoles"); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ListRolesResp> MetaServiceSvIf::semifuture_listRoles(const ::nebula::meta::cpp2::ListRolesReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::meta::cpp2::ListRolesResp& _return) { listRoles(_return, p_req); }); +} + +folly::Future< ::nebula::meta::cpp2::ListRolesResp> MetaServiceSvIf::future_listRoles(const ::nebula::meta::cpp2::ListRolesReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_listRoles(p_req), std::move(ka)); +} + +void MetaServiceSvIf::async_tm_listRoles(std::unique_ptr> callback, const ::nebula::meta::cpp2::ListRolesReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_listRoles(p_req); + }); +} + +void MetaServiceSvIf::getUserRoles( ::nebula::meta::cpp2::ListRolesResp& /*_return*/, const ::nebula::meta::cpp2::GetUserRolesReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("getUserRoles"); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ListRolesResp> MetaServiceSvIf::semifuture_getUserRoles(const ::nebula::meta::cpp2::GetUserRolesReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::meta::cpp2::ListRolesResp& _return) { getUserRoles(_return, p_req); }); +} + +folly::Future< ::nebula::meta::cpp2::ListRolesResp> MetaServiceSvIf::future_getUserRoles(const ::nebula::meta::cpp2::GetUserRolesReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_getUserRoles(p_req), std::move(ka)); +} + +void MetaServiceSvIf::async_tm_getUserRoles(std::unique_ptr> callback, const ::nebula::meta::cpp2::GetUserRolesReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_getUserRoles(p_req); + }); +} + +void MetaServiceSvIf::changePassword( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::ChangePasswordReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("changePassword"); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceSvIf::semifuture_changePassword(const ::nebula::meta::cpp2::ChangePasswordReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::meta::cpp2::ExecResp& _return) { changePassword(_return, p_req); }); +} + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceSvIf::future_changePassword(const ::nebula::meta::cpp2::ChangePasswordReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_changePassword(p_req), std::move(ka)); +} + +void MetaServiceSvIf::async_tm_changePassword(std::unique_ptr> callback, const ::nebula::meta::cpp2::ChangePasswordReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_changePassword(p_req); + }); +} + +void MetaServiceSvIf::heartBeat( ::nebula::meta::cpp2::HBResp& /*_return*/, const ::nebula::meta::cpp2::HBReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("heartBeat"); +} + +folly::SemiFuture< ::nebula::meta::cpp2::HBResp> MetaServiceSvIf::semifuture_heartBeat(const ::nebula::meta::cpp2::HBReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::meta::cpp2::HBResp& _return) { heartBeat(_return, p_req); }); +} + +folly::Future< ::nebula::meta::cpp2::HBResp> MetaServiceSvIf::future_heartBeat(const ::nebula::meta::cpp2::HBReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_heartBeat(p_req), std::move(ka)); +} + +void MetaServiceSvIf::async_tm_heartBeat(std::unique_ptr> callback, const ::nebula::meta::cpp2::HBReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_heartBeat(p_req); + }); +} + +void MetaServiceSvIf::balance( ::nebula::meta::cpp2::BalanceResp& /*_return*/, const ::nebula::meta::cpp2::BalanceReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("balance"); +} + +folly::SemiFuture< ::nebula::meta::cpp2::BalanceResp> MetaServiceSvIf::semifuture_balance(const ::nebula::meta::cpp2::BalanceReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::meta::cpp2::BalanceResp& _return) { balance(_return, p_req); }); +} + +folly::Future< ::nebula::meta::cpp2::BalanceResp> MetaServiceSvIf::future_balance(const ::nebula::meta::cpp2::BalanceReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_balance(p_req), std::move(ka)); +} + +void MetaServiceSvIf::async_tm_balance(std::unique_ptr> callback, const ::nebula::meta::cpp2::BalanceReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_balance(p_req); + }); +} + +void MetaServiceSvIf::leaderBalance( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::LeaderBalanceReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("leaderBalance"); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceSvIf::semifuture_leaderBalance(const ::nebula::meta::cpp2::LeaderBalanceReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::meta::cpp2::ExecResp& _return) { leaderBalance(_return, p_req); }); +} + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceSvIf::future_leaderBalance(const ::nebula::meta::cpp2::LeaderBalanceReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_leaderBalance(p_req), std::move(ka)); +} + +void MetaServiceSvIf::async_tm_leaderBalance(std::unique_ptr> callback, const ::nebula::meta::cpp2::LeaderBalanceReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_leaderBalance(p_req); + }); +} + +void MetaServiceSvIf::regConfig( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::RegConfigReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("regConfig"); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceSvIf::semifuture_regConfig(const ::nebula::meta::cpp2::RegConfigReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::meta::cpp2::ExecResp& _return) { regConfig(_return, p_req); }); +} + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceSvIf::future_regConfig(const ::nebula::meta::cpp2::RegConfigReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_regConfig(p_req), std::move(ka)); +} + +void MetaServiceSvIf::async_tm_regConfig(std::unique_ptr> callback, const ::nebula::meta::cpp2::RegConfigReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_regConfig(p_req); + }); +} + +void MetaServiceSvIf::getConfig( ::nebula::meta::cpp2::GetConfigResp& /*_return*/, const ::nebula::meta::cpp2::GetConfigReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("getConfig"); +} + +folly::SemiFuture< ::nebula::meta::cpp2::GetConfigResp> MetaServiceSvIf::semifuture_getConfig(const ::nebula::meta::cpp2::GetConfigReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::meta::cpp2::GetConfigResp& _return) { getConfig(_return, p_req); }); +} + +folly::Future< ::nebula::meta::cpp2::GetConfigResp> MetaServiceSvIf::future_getConfig(const ::nebula::meta::cpp2::GetConfigReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_getConfig(p_req), std::move(ka)); +} + +void MetaServiceSvIf::async_tm_getConfig(std::unique_ptr> callback, const ::nebula::meta::cpp2::GetConfigReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_getConfig(p_req); + }); +} + +void MetaServiceSvIf::setConfig( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::SetConfigReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("setConfig"); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceSvIf::semifuture_setConfig(const ::nebula::meta::cpp2::SetConfigReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::meta::cpp2::ExecResp& _return) { setConfig(_return, p_req); }); +} + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceSvIf::future_setConfig(const ::nebula::meta::cpp2::SetConfigReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_setConfig(p_req), std::move(ka)); +} + +void MetaServiceSvIf::async_tm_setConfig(std::unique_ptr> callback, const ::nebula::meta::cpp2::SetConfigReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_setConfig(p_req); + }); +} + +void MetaServiceSvIf::listConfigs( ::nebula::meta::cpp2::ListConfigsResp& /*_return*/, const ::nebula::meta::cpp2::ListConfigsReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("listConfigs"); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ListConfigsResp> MetaServiceSvIf::semifuture_listConfigs(const ::nebula::meta::cpp2::ListConfigsReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::meta::cpp2::ListConfigsResp& _return) { listConfigs(_return, p_req); }); +} + +folly::Future< ::nebula::meta::cpp2::ListConfigsResp> MetaServiceSvIf::future_listConfigs(const ::nebula::meta::cpp2::ListConfigsReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_listConfigs(p_req), std::move(ka)); +} + +void MetaServiceSvIf::async_tm_listConfigs(std::unique_ptr> callback, const ::nebula::meta::cpp2::ListConfigsReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_listConfigs(p_req); + }); +} + +void MetaServiceSvIf::createSnapshot( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::CreateSnapshotReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("createSnapshot"); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceSvIf::semifuture_createSnapshot(const ::nebula::meta::cpp2::CreateSnapshotReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::meta::cpp2::ExecResp& _return) { createSnapshot(_return, p_req); }); +} + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceSvIf::future_createSnapshot(const ::nebula::meta::cpp2::CreateSnapshotReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_createSnapshot(p_req), std::move(ka)); +} + +void MetaServiceSvIf::async_tm_createSnapshot(std::unique_ptr> callback, const ::nebula::meta::cpp2::CreateSnapshotReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_createSnapshot(p_req); + }); +} + +void MetaServiceSvIf::dropSnapshot( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::DropSnapshotReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("dropSnapshot"); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceSvIf::semifuture_dropSnapshot(const ::nebula::meta::cpp2::DropSnapshotReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::meta::cpp2::ExecResp& _return) { dropSnapshot(_return, p_req); }); +} + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceSvIf::future_dropSnapshot(const ::nebula::meta::cpp2::DropSnapshotReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_dropSnapshot(p_req), std::move(ka)); +} + +void MetaServiceSvIf::async_tm_dropSnapshot(std::unique_ptr> callback, const ::nebula::meta::cpp2::DropSnapshotReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_dropSnapshot(p_req); + }); +} + +void MetaServiceSvIf::listSnapshots( ::nebula::meta::cpp2::ListSnapshotsResp& /*_return*/, const ::nebula::meta::cpp2::ListSnapshotsReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("listSnapshots"); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ListSnapshotsResp> MetaServiceSvIf::semifuture_listSnapshots(const ::nebula::meta::cpp2::ListSnapshotsReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::meta::cpp2::ListSnapshotsResp& _return) { listSnapshots(_return, p_req); }); +} + +folly::Future< ::nebula::meta::cpp2::ListSnapshotsResp> MetaServiceSvIf::future_listSnapshots(const ::nebula::meta::cpp2::ListSnapshotsReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_listSnapshots(p_req), std::move(ka)); +} + +void MetaServiceSvIf::async_tm_listSnapshots(std::unique_ptr> callback, const ::nebula::meta::cpp2::ListSnapshotsReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_listSnapshots(p_req); + }); +} + +void MetaServiceSvIf::runAdminJob( ::nebula::meta::cpp2::AdminJobResp& /*_return*/, const ::nebula::meta::cpp2::AdminJobReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("runAdminJob"); +} + +folly::SemiFuture< ::nebula::meta::cpp2::AdminJobResp> MetaServiceSvIf::semifuture_runAdminJob(const ::nebula::meta::cpp2::AdminJobReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::meta::cpp2::AdminJobResp& _return) { runAdminJob(_return, p_req); }); +} + +folly::Future< ::nebula::meta::cpp2::AdminJobResp> MetaServiceSvIf::future_runAdminJob(const ::nebula::meta::cpp2::AdminJobReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_runAdminJob(p_req), std::move(ka)); +} + +void MetaServiceSvIf::async_tm_runAdminJob(std::unique_ptr> callback, const ::nebula::meta::cpp2::AdminJobReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_runAdminJob(p_req); + }); +} + +void MetaServiceSvIf::addZone( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::AddZoneReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("addZone"); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceSvIf::semifuture_addZone(const ::nebula::meta::cpp2::AddZoneReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::meta::cpp2::ExecResp& _return) { addZone(_return, p_req); }); +} + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceSvIf::future_addZone(const ::nebula::meta::cpp2::AddZoneReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_addZone(p_req), std::move(ka)); +} + +void MetaServiceSvIf::async_tm_addZone(std::unique_ptr> callback, const ::nebula::meta::cpp2::AddZoneReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_addZone(p_req); + }); +} + +void MetaServiceSvIf::dropZone( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::DropZoneReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("dropZone"); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceSvIf::semifuture_dropZone(const ::nebula::meta::cpp2::DropZoneReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::meta::cpp2::ExecResp& _return) { dropZone(_return, p_req); }); +} + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceSvIf::future_dropZone(const ::nebula::meta::cpp2::DropZoneReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_dropZone(p_req), std::move(ka)); +} + +void MetaServiceSvIf::async_tm_dropZone(std::unique_ptr> callback, const ::nebula::meta::cpp2::DropZoneReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_dropZone(p_req); + }); +} + +void MetaServiceSvIf::addHostIntoZone( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::AddHostIntoZoneReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("addHostIntoZone"); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceSvIf::semifuture_addHostIntoZone(const ::nebula::meta::cpp2::AddHostIntoZoneReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::meta::cpp2::ExecResp& _return) { addHostIntoZone(_return, p_req); }); +} + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceSvIf::future_addHostIntoZone(const ::nebula::meta::cpp2::AddHostIntoZoneReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_addHostIntoZone(p_req), std::move(ka)); +} + +void MetaServiceSvIf::async_tm_addHostIntoZone(std::unique_ptr> callback, const ::nebula::meta::cpp2::AddHostIntoZoneReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_addHostIntoZone(p_req); + }); +} + +void MetaServiceSvIf::dropHostFromZone( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::DropHostFromZoneReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("dropHostFromZone"); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceSvIf::semifuture_dropHostFromZone(const ::nebula::meta::cpp2::DropHostFromZoneReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::meta::cpp2::ExecResp& _return) { dropHostFromZone(_return, p_req); }); +} + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceSvIf::future_dropHostFromZone(const ::nebula::meta::cpp2::DropHostFromZoneReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_dropHostFromZone(p_req), std::move(ka)); +} + +void MetaServiceSvIf::async_tm_dropHostFromZone(std::unique_ptr> callback, const ::nebula::meta::cpp2::DropHostFromZoneReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_dropHostFromZone(p_req); + }); +} + +void MetaServiceSvIf::getZone( ::nebula::meta::cpp2::GetZoneResp& /*_return*/, const ::nebula::meta::cpp2::GetZoneReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("getZone"); +} + +folly::SemiFuture< ::nebula::meta::cpp2::GetZoneResp> MetaServiceSvIf::semifuture_getZone(const ::nebula::meta::cpp2::GetZoneReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::meta::cpp2::GetZoneResp& _return) { getZone(_return, p_req); }); +} + +folly::Future< ::nebula::meta::cpp2::GetZoneResp> MetaServiceSvIf::future_getZone(const ::nebula::meta::cpp2::GetZoneReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_getZone(p_req), std::move(ka)); +} + +void MetaServiceSvIf::async_tm_getZone(std::unique_ptr> callback, const ::nebula::meta::cpp2::GetZoneReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_getZone(p_req); + }); +} + +void MetaServiceSvIf::listZones( ::nebula::meta::cpp2::ListZonesResp& /*_return*/, const ::nebula::meta::cpp2::ListZonesReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("listZones"); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ListZonesResp> MetaServiceSvIf::semifuture_listZones(const ::nebula::meta::cpp2::ListZonesReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::meta::cpp2::ListZonesResp& _return) { listZones(_return, p_req); }); +} + +folly::Future< ::nebula::meta::cpp2::ListZonesResp> MetaServiceSvIf::future_listZones(const ::nebula::meta::cpp2::ListZonesReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_listZones(p_req), std::move(ka)); +} + +void MetaServiceSvIf::async_tm_listZones(std::unique_ptr> callback, const ::nebula::meta::cpp2::ListZonesReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_listZones(p_req); + }); +} + +void MetaServiceSvIf::addGroup( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::AddGroupReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("addGroup"); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceSvIf::semifuture_addGroup(const ::nebula::meta::cpp2::AddGroupReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::meta::cpp2::ExecResp& _return) { addGroup(_return, p_req); }); +} + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceSvIf::future_addGroup(const ::nebula::meta::cpp2::AddGroupReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_addGroup(p_req), std::move(ka)); +} + +void MetaServiceSvIf::async_tm_addGroup(std::unique_ptr> callback, const ::nebula::meta::cpp2::AddGroupReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_addGroup(p_req); + }); +} + +void MetaServiceSvIf::dropGroup( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::DropGroupReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("dropGroup"); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceSvIf::semifuture_dropGroup(const ::nebula::meta::cpp2::DropGroupReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::meta::cpp2::ExecResp& _return) { dropGroup(_return, p_req); }); +} + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceSvIf::future_dropGroup(const ::nebula::meta::cpp2::DropGroupReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_dropGroup(p_req), std::move(ka)); +} + +void MetaServiceSvIf::async_tm_dropGroup(std::unique_ptr> callback, const ::nebula::meta::cpp2::DropGroupReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_dropGroup(p_req); + }); +} + +void MetaServiceSvIf::addZoneIntoGroup( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::AddZoneIntoGroupReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("addZoneIntoGroup"); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceSvIf::semifuture_addZoneIntoGroup(const ::nebula::meta::cpp2::AddZoneIntoGroupReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::meta::cpp2::ExecResp& _return) { addZoneIntoGroup(_return, p_req); }); +} + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceSvIf::future_addZoneIntoGroup(const ::nebula::meta::cpp2::AddZoneIntoGroupReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_addZoneIntoGroup(p_req), std::move(ka)); +} + +void MetaServiceSvIf::async_tm_addZoneIntoGroup(std::unique_ptr> callback, const ::nebula::meta::cpp2::AddZoneIntoGroupReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_addZoneIntoGroup(p_req); + }); +} + +void MetaServiceSvIf::dropZoneFromGroup( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::DropZoneFromGroupReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("dropZoneFromGroup"); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceSvIf::semifuture_dropZoneFromGroup(const ::nebula::meta::cpp2::DropZoneFromGroupReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::meta::cpp2::ExecResp& _return) { dropZoneFromGroup(_return, p_req); }); +} + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceSvIf::future_dropZoneFromGroup(const ::nebula::meta::cpp2::DropZoneFromGroupReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_dropZoneFromGroup(p_req), std::move(ka)); +} + +void MetaServiceSvIf::async_tm_dropZoneFromGroup(std::unique_ptr> callback, const ::nebula::meta::cpp2::DropZoneFromGroupReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_dropZoneFromGroup(p_req); + }); +} + +void MetaServiceSvIf::getGroup( ::nebula::meta::cpp2::GetGroupResp& /*_return*/, const ::nebula::meta::cpp2::GetGroupReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("getGroup"); +} + +folly::SemiFuture< ::nebula::meta::cpp2::GetGroupResp> MetaServiceSvIf::semifuture_getGroup(const ::nebula::meta::cpp2::GetGroupReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::meta::cpp2::GetGroupResp& _return) { getGroup(_return, p_req); }); +} + +folly::Future< ::nebula::meta::cpp2::GetGroupResp> MetaServiceSvIf::future_getGroup(const ::nebula::meta::cpp2::GetGroupReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_getGroup(p_req), std::move(ka)); +} + +void MetaServiceSvIf::async_tm_getGroup(std::unique_ptr> callback, const ::nebula::meta::cpp2::GetGroupReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_getGroup(p_req); + }); +} + +void MetaServiceSvIf::listGroups( ::nebula::meta::cpp2::ListGroupsResp& /*_return*/, const ::nebula::meta::cpp2::ListGroupsReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("listGroups"); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ListGroupsResp> MetaServiceSvIf::semifuture_listGroups(const ::nebula::meta::cpp2::ListGroupsReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::meta::cpp2::ListGroupsResp& _return) { listGroups(_return, p_req); }); +} + +folly::Future< ::nebula::meta::cpp2::ListGroupsResp> MetaServiceSvIf::future_listGroups(const ::nebula::meta::cpp2::ListGroupsReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_listGroups(p_req), std::move(ka)); +} + +void MetaServiceSvIf::async_tm_listGroups(std::unique_ptr> callback, const ::nebula::meta::cpp2::ListGroupsReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_listGroups(p_req); + }); +} + +void MetaServiceSvIf::createBackup( ::nebula::meta::cpp2::CreateBackupResp& /*_return*/, const ::nebula::meta::cpp2::CreateBackupReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("createBackup"); +} + +folly::SemiFuture< ::nebula::meta::cpp2::CreateBackupResp> MetaServiceSvIf::semifuture_createBackup(const ::nebula::meta::cpp2::CreateBackupReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::meta::cpp2::CreateBackupResp& _return) { createBackup(_return, p_req); }); +} + +folly::Future< ::nebula::meta::cpp2::CreateBackupResp> MetaServiceSvIf::future_createBackup(const ::nebula::meta::cpp2::CreateBackupReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_createBackup(p_req), std::move(ka)); +} + +void MetaServiceSvIf::async_tm_createBackup(std::unique_ptr> callback, const ::nebula::meta::cpp2::CreateBackupReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_createBackup(p_req); + }); +} + +void MetaServiceSvIf::restoreMeta( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::RestoreMetaReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("restoreMeta"); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceSvIf::semifuture_restoreMeta(const ::nebula::meta::cpp2::RestoreMetaReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::meta::cpp2::ExecResp& _return) { restoreMeta(_return, p_req); }); +} + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceSvIf::future_restoreMeta(const ::nebula::meta::cpp2::RestoreMetaReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_restoreMeta(p_req), std::move(ka)); +} + +void MetaServiceSvIf::async_tm_restoreMeta(std::unique_ptr> callback, const ::nebula::meta::cpp2::RestoreMetaReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_restoreMeta(p_req); + }); +} + +void MetaServiceSvIf::addListener( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::AddListenerReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("addListener"); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceSvIf::semifuture_addListener(const ::nebula::meta::cpp2::AddListenerReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::meta::cpp2::ExecResp& _return) { addListener(_return, p_req); }); +} + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceSvIf::future_addListener(const ::nebula::meta::cpp2::AddListenerReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_addListener(p_req), std::move(ka)); +} + +void MetaServiceSvIf::async_tm_addListener(std::unique_ptr> callback, const ::nebula::meta::cpp2::AddListenerReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_addListener(p_req); + }); +} + +void MetaServiceSvIf::removeListener( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::RemoveListenerReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("removeListener"); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceSvIf::semifuture_removeListener(const ::nebula::meta::cpp2::RemoveListenerReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::meta::cpp2::ExecResp& _return) { removeListener(_return, p_req); }); +} + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceSvIf::future_removeListener(const ::nebula::meta::cpp2::RemoveListenerReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_removeListener(p_req), std::move(ka)); +} + +void MetaServiceSvIf::async_tm_removeListener(std::unique_ptr> callback, const ::nebula::meta::cpp2::RemoveListenerReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_removeListener(p_req); + }); +} + +void MetaServiceSvIf::listListener( ::nebula::meta::cpp2::ListListenerResp& /*_return*/, const ::nebula::meta::cpp2::ListListenerReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("listListener"); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ListListenerResp> MetaServiceSvIf::semifuture_listListener(const ::nebula::meta::cpp2::ListListenerReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::meta::cpp2::ListListenerResp& _return) { listListener(_return, p_req); }); +} + +folly::Future< ::nebula::meta::cpp2::ListListenerResp> MetaServiceSvIf::future_listListener(const ::nebula::meta::cpp2::ListListenerReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_listListener(p_req), std::move(ka)); +} + +void MetaServiceSvIf::async_tm_listListener(std::unique_ptr> callback, const ::nebula::meta::cpp2::ListListenerReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_listListener(p_req); + }); +} + +void MetaServiceSvIf::getStats( ::nebula::meta::cpp2::GetStatsResp& /*_return*/, const ::nebula::meta::cpp2::GetStatsReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("getStats"); +} + +folly::SemiFuture< ::nebula::meta::cpp2::GetStatsResp> MetaServiceSvIf::semifuture_getStats(const ::nebula::meta::cpp2::GetStatsReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::meta::cpp2::GetStatsResp& _return) { getStats(_return, p_req); }); +} + +folly::Future< ::nebula::meta::cpp2::GetStatsResp> MetaServiceSvIf::future_getStats(const ::nebula::meta::cpp2::GetStatsReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_getStats(p_req), std::move(ka)); +} + +void MetaServiceSvIf::async_tm_getStats(std::unique_ptr> callback, const ::nebula::meta::cpp2::GetStatsReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_getStats(p_req); + }); +} + +void MetaServiceSvIf::signInFTService( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::SignInFTServiceReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("signInFTService"); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceSvIf::semifuture_signInFTService(const ::nebula::meta::cpp2::SignInFTServiceReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::meta::cpp2::ExecResp& _return) { signInFTService(_return, p_req); }); +} + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceSvIf::future_signInFTService(const ::nebula::meta::cpp2::SignInFTServiceReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_signInFTService(p_req), std::move(ka)); +} + +void MetaServiceSvIf::async_tm_signInFTService(std::unique_ptr> callback, const ::nebula::meta::cpp2::SignInFTServiceReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_signInFTService(p_req); + }); +} + +void MetaServiceSvIf::signOutFTService( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::SignOutFTServiceReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("signOutFTService"); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceSvIf::semifuture_signOutFTService(const ::nebula::meta::cpp2::SignOutFTServiceReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::meta::cpp2::ExecResp& _return) { signOutFTService(_return, p_req); }); +} + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceSvIf::future_signOutFTService(const ::nebula::meta::cpp2::SignOutFTServiceReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_signOutFTService(p_req), std::move(ka)); +} + +void MetaServiceSvIf::async_tm_signOutFTService(std::unique_ptr> callback, const ::nebula::meta::cpp2::SignOutFTServiceReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_signOutFTService(p_req); + }); +} + +void MetaServiceSvIf::listFTClients( ::nebula::meta::cpp2::ListFTClientsResp& /*_return*/, const ::nebula::meta::cpp2::ListFTClientsReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("listFTClients"); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ListFTClientsResp> MetaServiceSvIf::semifuture_listFTClients(const ::nebula::meta::cpp2::ListFTClientsReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::meta::cpp2::ListFTClientsResp& _return) { listFTClients(_return, p_req); }); +} + +folly::Future< ::nebula::meta::cpp2::ListFTClientsResp> MetaServiceSvIf::future_listFTClients(const ::nebula::meta::cpp2::ListFTClientsReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_listFTClients(p_req), std::move(ka)); +} + +void MetaServiceSvIf::async_tm_listFTClients(std::unique_ptr> callback, const ::nebula::meta::cpp2::ListFTClientsReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_listFTClients(p_req); + }); +} + +void MetaServiceSvIf::createFTIndex( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::CreateFTIndexReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("createFTIndex"); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceSvIf::semifuture_createFTIndex(const ::nebula::meta::cpp2::CreateFTIndexReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::meta::cpp2::ExecResp& _return) { createFTIndex(_return, p_req); }); +} + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceSvIf::future_createFTIndex(const ::nebula::meta::cpp2::CreateFTIndexReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_createFTIndex(p_req), std::move(ka)); +} + +void MetaServiceSvIf::async_tm_createFTIndex(std::unique_ptr> callback, const ::nebula::meta::cpp2::CreateFTIndexReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_createFTIndex(p_req); + }); +} + +void MetaServiceSvIf::dropFTIndex( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::DropFTIndexReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("dropFTIndex"); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceSvIf::semifuture_dropFTIndex(const ::nebula::meta::cpp2::DropFTIndexReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::meta::cpp2::ExecResp& _return) { dropFTIndex(_return, p_req); }); +} + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceSvIf::future_dropFTIndex(const ::nebula::meta::cpp2::DropFTIndexReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_dropFTIndex(p_req), std::move(ka)); +} + +void MetaServiceSvIf::async_tm_dropFTIndex(std::unique_ptr> callback, const ::nebula::meta::cpp2::DropFTIndexReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_dropFTIndex(p_req); + }); +} + +void MetaServiceSvIf::listFTIndexes( ::nebula::meta::cpp2::ListFTIndexesResp& /*_return*/, const ::nebula::meta::cpp2::ListFTIndexesReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("listFTIndexes"); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ListFTIndexesResp> MetaServiceSvIf::semifuture_listFTIndexes(const ::nebula::meta::cpp2::ListFTIndexesReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::meta::cpp2::ListFTIndexesResp& _return) { listFTIndexes(_return, p_req); }); +} + +folly::Future< ::nebula::meta::cpp2::ListFTIndexesResp> MetaServiceSvIf::future_listFTIndexes(const ::nebula::meta::cpp2::ListFTIndexesReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_listFTIndexes(p_req), std::move(ka)); +} + +void MetaServiceSvIf::async_tm_listFTIndexes(std::unique_ptr> callback, const ::nebula::meta::cpp2::ListFTIndexesReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_listFTIndexes(p_req); + }); +} + +void MetaServiceSvIf::createSession( ::nebula::meta::cpp2::CreateSessionResp& /*_return*/, const ::nebula::meta::cpp2::CreateSessionReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("createSession"); +} + +folly::SemiFuture< ::nebula::meta::cpp2::CreateSessionResp> MetaServiceSvIf::semifuture_createSession(const ::nebula::meta::cpp2::CreateSessionReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::meta::cpp2::CreateSessionResp& _return) { createSession(_return, p_req); }); +} + +folly::Future< ::nebula::meta::cpp2::CreateSessionResp> MetaServiceSvIf::future_createSession(const ::nebula::meta::cpp2::CreateSessionReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_createSession(p_req), std::move(ka)); +} + +void MetaServiceSvIf::async_tm_createSession(std::unique_ptr> callback, const ::nebula::meta::cpp2::CreateSessionReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_createSession(p_req); + }); +} + +void MetaServiceSvIf::updateSessions( ::nebula::meta::cpp2::UpdateSessionsResp& /*_return*/, const ::nebula::meta::cpp2::UpdateSessionsReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("updateSessions"); +} + +folly::SemiFuture< ::nebula::meta::cpp2::UpdateSessionsResp> MetaServiceSvIf::semifuture_updateSessions(const ::nebula::meta::cpp2::UpdateSessionsReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::meta::cpp2::UpdateSessionsResp& _return) { updateSessions(_return, p_req); }); +} + +folly::Future< ::nebula::meta::cpp2::UpdateSessionsResp> MetaServiceSvIf::future_updateSessions(const ::nebula::meta::cpp2::UpdateSessionsReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_updateSessions(p_req), std::move(ka)); +} + +void MetaServiceSvIf::async_tm_updateSessions(std::unique_ptr> callback, const ::nebula::meta::cpp2::UpdateSessionsReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_updateSessions(p_req); + }); +} + +void MetaServiceSvIf::listSessions( ::nebula::meta::cpp2::ListSessionsResp& /*_return*/, const ::nebula::meta::cpp2::ListSessionsReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("listSessions"); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ListSessionsResp> MetaServiceSvIf::semifuture_listSessions(const ::nebula::meta::cpp2::ListSessionsReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::meta::cpp2::ListSessionsResp& _return) { listSessions(_return, p_req); }); +} + +folly::Future< ::nebula::meta::cpp2::ListSessionsResp> MetaServiceSvIf::future_listSessions(const ::nebula::meta::cpp2::ListSessionsReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_listSessions(p_req), std::move(ka)); +} + +void MetaServiceSvIf::async_tm_listSessions(std::unique_ptr> callback, const ::nebula::meta::cpp2::ListSessionsReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_listSessions(p_req); + }); +} + +void MetaServiceSvIf::getSession( ::nebula::meta::cpp2::GetSessionResp& /*_return*/, const ::nebula::meta::cpp2::GetSessionReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("getSession"); +} + +folly::SemiFuture< ::nebula::meta::cpp2::GetSessionResp> MetaServiceSvIf::semifuture_getSession(const ::nebula::meta::cpp2::GetSessionReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::meta::cpp2::GetSessionResp& _return) { getSession(_return, p_req); }); +} + +folly::Future< ::nebula::meta::cpp2::GetSessionResp> MetaServiceSvIf::future_getSession(const ::nebula::meta::cpp2::GetSessionReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_getSession(p_req), std::move(ka)); +} + +void MetaServiceSvIf::async_tm_getSession(std::unique_ptr> callback, const ::nebula::meta::cpp2::GetSessionReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_getSession(p_req); + }); +} + +void MetaServiceSvIf::removeSession( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::RemoveSessionReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("removeSession"); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceSvIf::semifuture_removeSession(const ::nebula::meta::cpp2::RemoveSessionReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::meta::cpp2::ExecResp& _return) { removeSession(_return, p_req); }); +} + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceSvIf::future_removeSession(const ::nebula::meta::cpp2::RemoveSessionReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_removeSession(p_req), std::move(ka)); +} + +void MetaServiceSvIf::async_tm_removeSession(std::unique_ptr> callback, const ::nebula::meta::cpp2::RemoveSessionReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_removeSession(p_req); + }); +} + +void MetaServiceSvIf::killQuery( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::KillQueryReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("killQuery"); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceSvIf::semifuture_killQuery(const ::nebula::meta::cpp2::KillQueryReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::meta::cpp2::ExecResp& _return) { killQuery(_return, p_req); }); +} + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceSvIf::future_killQuery(const ::nebula::meta::cpp2::KillQueryReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_killQuery(p_req), std::move(ka)); +} + +void MetaServiceSvIf::async_tm_killQuery(std::unique_ptr> callback, const ::nebula::meta::cpp2::KillQueryReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_killQuery(p_req); + }); +} + +void MetaServiceSvIf::reportTaskFinish( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::ReportTaskReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("reportTaskFinish"); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceSvIf::semifuture_reportTaskFinish(const ::nebula::meta::cpp2::ReportTaskReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::meta::cpp2::ExecResp& _return) { reportTaskFinish(_return, p_req); }); +} + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceSvIf::future_reportTaskFinish(const ::nebula::meta::cpp2::ReportTaskReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_reportTaskFinish(p_req), std::move(ka)); +} + +void MetaServiceSvIf::async_tm_reportTaskFinish(std::unique_ptr> callback, const ::nebula::meta::cpp2::ReportTaskReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_reportTaskFinish(p_req); + }); +} + +void MetaServiceSvIf::listCluster( ::nebula::meta::cpp2::ListClusterInfoResp& /*_return*/, const ::nebula::meta::cpp2::ListClusterInfoReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("listCluster"); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ListClusterInfoResp> MetaServiceSvIf::semifuture_listCluster(const ::nebula::meta::cpp2::ListClusterInfoReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::meta::cpp2::ListClusterInfoResp& _return) { listCluster(_return, p_req); }); +} + +folly::Future< ::nebula::meta::cpp2::ListClusterInfoResp> MetaServiceSvIf::future_listCluster(const ::nebula::meta::cpp2::ListClusterInfoReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_listCluster(p_req), std::move(ka)); +} + +void MetaServiceSvIf::async_tm_listCluster(std::unique_ptr> callback, const ::nebula::meta::cpp2::ListClusterInfoReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_listCluster(p_req); + }); +} + +void MetaServiceSvIf::getMetaDirInfo( ::nebula::meta::cpp2::GetMetaDirInfoResp& /*_return*/, const ::nebula::meta::cpp2::GetMetaDirInfoReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("getMetaDirInfo"); +} + +folly::SemiFuture< ::nebula::meta::cpp2::GetMetaDirInfoResp> MetaServiceSvIf::semifuture_getMetaDirInfo(const ::nebula::meta::cpp2::GetMetaDirInfoReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::meta::cpp2::GetMetaDirInfoResp& _return) { getMetaDirInfo(_return, p_req); }); +} + +folly::Future< ::nebula::meta::cpp2::GetMetaDirInfoResp> MetaServiceSvIf::future_getMetaDirInfo(const ::nebula::meta::cpp2::GetMetaDirInfoReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_getMetaDirInfo(p_req), std::move(ka)); +} + +void MetaServiceSvIf::async_tm_getMetaDirInfo(std::unique_ptr> callback, const ::nebula::meta::cpp2::GetMetaDirInfoReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_getMetaDirInfo(p_req); + }); +} + +void MetaServiceSvIf::verifyClientVersion( ::nebula::meta::cpp2::VerifyClientVersionResp& /*_return*/, const ::nebula::meta::cpp2::VerifyClientVersionReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("verifyClientVersion"); +} + +folly::SemiFuture< ::nebula::meta::cpp2::VerifyClientVersionResp> MetaServiceSvIf::semifuture_verifyClientVersion(const ::nebula::meta::cpp2::VerifyClientVersionReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::meta::cpp2::VerifyClientVersionResp& _return) { verifyClientVersion(_return, p_req); }); +} + +folly::Future< ::nebula::meta::cpp2::VerifyClientVersionResp> MetaServiceSvIf::future_verifyClientVersion(const ::nebula::meta::cpp2::VerifyClientVersionReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_verifyClientVersion(p_req), std::move(ka)); +} + +void MetaServiceSvIf::async_tm_verifyClientVersion(std::unique_ptr> callback, const ::nebula::meta::cpp2::VerifyClientVersionReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_verifyClientVersion(p_req); + }); +} + +void MetaServiceSvNull::createSpace( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::CreateSpaceReq& /*req*/) {} + +void MetaServiceSvNull::dropSpace( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::DropSpaceReq& /*req*/) {} + +void MetaServiceSvNull::getSpace( ::nebula::meta::cpp2::GetSpaceResp& /*_return*/, const ::nebula::meta::cpp2::GetSpaceReq& /*req*/) {} + +void MetaServiceSvNull::listSpaces( ::nebula::meta::cpp2::ListSpacesResp& /*_return*/, const ::nebula::meta::cpp2::ListSpacesReq& /*req*/) {} + +void MetaServiceSvNull::createSpaceAs( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::CreateSpaceAsReq& /*req*/) {} + +void MetaServiceSvNull::createTag( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::CreateTagReq& /*req*/) {} + +void MetaServiceSvNull::alterTag( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::AlterTagReq& /*req*/) {} + +void MetaServiceSvNull::dropTag( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::DropTagReq& /*req*/) {} + +void MetaServiceSvNull::getTag( ::nebula::meta::cpp2::GetTagResp& /*_return*/, const ::nebula::meta::cpp2::GetTagReq& /*req*/) {} + +void MetaServiceSvNull::listTags( ::nebula::meta::cpp2::ListTagsResp& /*_return*/, const ::nebula::meta::cpp2::ListTagsReq& /*req*/) {} + +void MetaServiceSvNull::createEdge( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::CreateEdgeReq& /*req*/) {} + +void MetaServiceSvNull::alterEdge( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::AlterEdgeReq& /*req*/) {} + +void MetaServiceSvNull::dropEdge( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::DropEdgeReq& /*req*/) {} + +void MetaServiceSvNull::getEdge( ::nebula::meta::cpp2::GetEdgeResp& /*_return*/, const ::nebula::meta::cpp2::GetEdgeReq& /*req*/) {} + +void MetaServiceSvNull::listEdges( ::nebula::meta::cpp2::ListEdgesResp& /*_return*/, const ::nebula::meta::cpp2::ListEdgesReq& /*req*/) {} + +void MetaServiceSvNull::listHosts( ::nebula::meta::cpp2::ListHostsResp& /*_return*/, const ::nebula::meta::cpp2::ListHostsReq& /*req*/) {} + +void MetaServiceSvNull::getPartsAlloc( ::nebula::meta::cpp2::GetPartsAllocResp& /*_return*/, const ::nebula::meta::cpp2::GetPartsAllocReq& /*req*/) {} + +void MetaServiceSvNull::listParts( ::nebula::meta::cpp2::ListPartsResp& /*_return*/, const ::nebula::meta::cpp2::ListPartsReq& /*req*/) {} + +void MetaServiceSvNull::multiPut( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::MultiPutReq& /*req*/) {} + +void MetaServiceSvNull::get( ::nebula::meta::cpp2::GetResp& /*_return*/, const ::nebula::meta::cpp2::GetReq& /*req*/) {} + +void MetaServiceSvNull::multiGet( ::nebula::meta::cpp2::MultiGetResp& /*_return*/, const ::nebula::meta::cpp2::MultiGetReq& /*req*/) {} + +void MetaServiceSvNull::remove( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::RemoveReq& /*req*/) {} + +void MetaServiceSvNull::removeRange( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::RemoveRangeReq& /*req*/) {} + +void MetaServiceSvNull::scan( ::nebula::meta::cpp2::ScanResp& /*_return*/, const ::nebula::meta::cpp2::ScanReq& /*req*/) {} + +void MetaServiceSvNull::createTagIndex( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::CreateTagIndexReq& /*req*/) {} + +void MetaServiceSvNull::dropTagIndex( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::DropTagIndexReq& /*req*/) {} + +void MetaServiceSvNull::getTagIndex( ::nebula::meta::cpp2::GetTagIndexResp& /*_return*/, const ::nebula::meta::cpp2::GetTagIndexReq& /*req*/) {} + +void MetaServiceSvNull::listTagIndexes( ::nebula::meta::cpp2::ListTagIndexesResp& /*_return*/, const ::nebula::meta::cpp2::ListTagIndexesReq& /*req*/) {} + +void MetaServiceSvNull::rebuildTagIndex( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::RebuildIndexReq& /*req*/) {} + +void MetaServiceSvNull::listTagIndexStatus( ::nebula::meta::cpp2::ListIndexStatusResp& /*_return*/, const ::nebula::meta::cpp2::ListIndexStatusReq& /*req*/) {} + +void MetaServiceSvNull::createEdgeIndex( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::CreateEdgeIndexReq& /*req*/) {} + +void MetaServiceSvNull::dropEdgeIndex( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::DropEdgeIndexReq& /*req*/) {} + +void MetaServiceSvNull::getEdgeIndex( ::nebula::meta::cpp2::GetEdgeIndexResp& /*_return*/, const ::nebula::meta::cpp2::GetEdgeIndexReq& /*req*/) {} + +void MetaServiceSvNull::listEdgeIndexes( ::nebula::meta::cpp2::ListEdgeIndexesResp& /*_return*/, const ::nebula::meta::cpp2::ListEdgeIndexesReq& /*req*/) {} + +void MetaServiceSvNull::rebuildEdgeIndex( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::RebuildIndexReq& /*req*/) {} + +void MetaServiceSvNull::listEdgeIndexStatus( ::nebula::meta::cpp2::ListIndexStatusResp& /*_return*/, const ::nebula::meta::cpp2::ListIndexStatusReq& /*req*/) {} + +void MetaServiceSvNull::createUser( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::CreateUserReq& /*req*/) {} + +void MetaServiceSvNull::dropUser( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::DropUserReq& /*req*/) {} + +void MetaServiceSvNull::alterUser( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::AlterUserReq& /*req*/) {} + +void MetaServiceSvNull::grantRole( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::GrantRoleReq& /*req*/) {} + +void MetaServiceSvNull::revokeRole( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::RevokeRoleReq& /*req*/) {} + +void MetaServiceSvNull::listUsers( ::nebula::meta::cpp2::ListUsersResp& /*_return*/, const ::nebula::meta::cpp2::ListUsersReq& /*req*/) {} + +void MetaServiceSvNull::listRoles( ::nebula::meta::cpp2::ListRolesResp& /*_return*/, const ::nebula::meta::cpp2::ListRolesReq& /*req*/) {} + +void MetaServiceSvNull::getUserRoles( ::nebula::meta::cpp2::ListRolesResp& /*_return*/, const ::nebula::meta::cpp2::GetUserRolesReq& /*req*/) {} + +void MetaServiceSvNull::changePassword( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::ChangePasswordReq& /*req*/) {} + +void MetaServiceSvNull::heartBeat( ::nebula::meta::cpp2::HBResp& /*_return*/, const ::nebula::meta::cpp2::HBReq& /*req*/) {} + +void MetaServiceSvNull::balance( ::nebula::meta::cpp2::BalanceResp& /*_return*/, const ::nebula::meta::cpp2::BalanceReq& /*req*/) {} + +void MetaServiceSvNull::leaderBalance( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::LeaderBalanceReq& /*req*/) {} + +void MetaServiceSvNull::regConfig( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::RegConfigReq& /*req*/) {} + +void MetaServiceSvNull::getConfig( ::nebula::meta::cpp2::GetConfigResp& /*_return*/, const ::nebula::meta::cpp2::GetConfigReq& /*req*/) {} + +void MetaServiceSvNull::setConfig( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::SetConfigReq& /*req*/) {} + +void MetaServiceSvNull::listConfigs( ::nebula::meta::cpp2::ListConfigsResp& /*_return*/, const ::nebula::meta::cpp2::ListConfigsReq& /*req*/) {} + +void MetaServiceSvNull::createSnapshot( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::CreateSnapshotReq& /*req*/) {} + +void MetaServiceSvNull::dropSnapshot( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::DropSnapshotReq& /*req*/) {} + +void MetaServiceSvNull::listSnapshots( ::nebula::meta::cpp2::ListSnapshotsResp& /*_return*/, const ::nebula::meta::cpp2::ListSnapshotsReq& /*req*/) {} + +void MetaServiceSvNull::runAdminJob( ::nebula::meta::cpp2::AdminJobResp& /*_return*/, const ::nebula::meta::cpp2::AdminJobReq& /*req*/) {} + +void MetaServiceSvNull::addZone( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::AddZoneReq& /*req*/) {} + +void MetaServiceSvNull::dropZone( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::DropZoneReq& /*req*/) {} + +void MetaServiceSvNull::addHostIntoZone( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::AddHostIntoZoneReq& /*req*/) {} + +void MetaServiceSvNull::dropHostFromZone( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::DropHostFromZoneReq& /*req*/) {} + +void MetaServiceSvNull::getZone( ::nebula::meta::cpp2::GetZoneResp& /*_return*/, const ::nebula::meta::cpp2::GetZoneReq& /*req*/) {} + +void MetaServiceSvNull::listZones( ::nebula::meta::cpp2::ListZonesResp& /*_return*/, const ::nebula::meta::cpp2::ListZonesReq& /*req*/) {} + +void MetaServiceSvNull::addGroup( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::AddGroupReq& /*req*/) {} + +void MetaServiceSvNull::dropGroup( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::DropGroupReq& /*req*/) {} + +void MetaServiceSvNull::addZoneIntoGroup( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::AddZoneIntoGroupReq& /*req*/) {} + +void MetaServiceSvNull::dropZoneFromGroup( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::DropZoneFromGroupReq& /*req*/) {} + +void MetaServiceSvNull::getGroup( ::nebula::meta::cpp2::GetGroupResp& /*_return*/, const ::nebula::meta::cpp2::GetGroupReq& /*req*/) {} + +void MetaServiceSvNull::listGroups( ::nebula::meta::cpp2::ListGroupsResp& /*_return*/, const ::nebula::meta::cpp2::ListGroupsReq& /*req*/) {} + +void MetaServiceSvNull::createBackup( ::nebula::meta::cpp2::CreateBackupResp& /*_return*/, const ::nebula::meta::cpp2::CreateBackupReq& /*req*/) {} + +void MetaServiceSvNull::restoreMeta( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::RestoreMetaReq& /*req*/) {} + +void MetaServiceSvNull::addListener( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::AddListenerReq& /*req*/) {} + +void MetaServiceSvNull::removeListener( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::RemoveListenerReq& /*req*/) {} + +void MetaServiceSvNull::listListener( ::nebula::meta::cpp2::ListListenerResp& /*_return*/, const ::nebula::meta::cpp2::ListListenerReq& /*req*/) {} + +void MetaServiceSvNull::getStats( ::nebula::meta::cpp2::GetStatsResp& /*_return*/, const ::nebula::meta::cpp2::GetStatsReq& /*req*/) {} + +void MetaServiceSvNull::signInFTService( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::SignInFTServiceReq& /*req*/) {} + +void MetaServiceSvNull::signOutFTService( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::SignOutFTServiceReq& /*req*/) {} + +void MetaServiceSvNull::listFTClients( ::nebula::meta::cpp2::ListFTClientsResp& /*_return*/, const ::nebula::meta::cpp2::ListFTClientsReq& /*req*/) {} + +void MetaServiceSvNull::createFTIndex( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::CreateFTIndexReq& /*req*/) {} + +void MetaServiceSvNull::dropFTIndex( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::DropFTIndexReq& /*req*/) {} + +void MetaServiceSvNull::listFTIndexes( ::nebula::meta::cpp2::ListFTIndexesResp& /*_return*/, const ::nebula::meta::cpp2::ListFTIndexesReq& /*req*/) {} + +void MetaServiceSvNull::createSession( ::nebula::meta::cpp2::CreateSessionResp& /*_return*/, const ::nebula::meta::cpp2::CreateSessionReq& /*req*/) {} + +void MetaServiceSvNull::updateSessions( ::nebula::meta::cpp2::UpdateSessionsResp& /*_return*/, const ::nebula::meta::cpp2::UpdateSessionsReq& /*req*/) {} + +void MetaServiceSvNull::listSessions( ::nebula::meta::cpp2::ListSessionsResp& /*_return*/, const ::nebula::meta::cpp2::ListSessionsReq& /*req*/) {} + +void MetaServiceSvNull::getSession( ::nebula::meta::cpp2::GetSessionResp& /*_return*/, const ::nebula::meta::cpp2::GetSessionReq& /*req*/) {} + +void MetaServiceSvNull::removeSession( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::RemoveSessionReq& /*req*/) {} + +void MetaServiceSvNull::killQuery( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::KillQueryReq& /*req*/) {} + +void MetaServiceSvNull::reportTaskFinish( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::ReportTaskReq& /*req*/) {} + +void MetaServiceSvNull::listCluster( ::nebula::meta::cpp2::ListClusterInfoResp& /*_return*/, const ::nebula::meta::cpp2::ListClusterInfoReq& /*req*/) {} + +void MetaServiceSvNull::getMetaDirInfo( ::nebula::meta::cpp2::GetMetaDirInfoResp& /*_return*/, const ::nebula::meta::cpp2::GetMetaDirInfoReq& /*req*/) {} + +void MetaServiceSvNull::verifyClientVersion( ::nebula::meta::cpp2::VerifyClientVersionResp& /*_return*/, const ::nebula::meta::cpp2::VerifyClientVersionReq& /*req*/) {} + + + +const char* MetaServiceAsyncProcessor::getServiceName() { + return "MetaService"; +} + +void MetaServiceAsyncProcessor::getServiceMetadata(apache::thrift::metadata::ThriftServiceMetadataResponse& response) { + ::apache::thrift::detail::md::ServiceMetadata::gen(*response.metadata_ref(), *response.context_ref()); +} + +void MetaServiceAsyncProcessor::processSerializedRequest(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::protocol::PROTOCOL_TYPES protType, apache::thrift::Cpp2RequestContext* context, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + apache::thrift::detail::ap::process(this, std::move(req), std::move(serializedRequest), protType, context, eb, tm); +} + +std::shared_ptr MetaServiceAsyncProcessor::getBaseContextForRequest() { + return iface_->getBaseContextForRequest(); +} + +const MetaServiceAsyncProcessor::ProcessMap& MetaServiceAsyncProcessor::getBinaryProtocolProcessMap() { + return binaryProcessMap_; +} + +const MetaServiceAsyncProcessor::ProcessMap MetaServiceAsyncProcessor::binaryProcessMap_ { + {"createSpace", &MetaServiceAsyncProcessor::setUpAndProcess_createSpace}, + {"dropSpace", &MetaServiceAsyncProcessor::setUpAndProcess_dropSpace}, + {"getSpace", &MetaServiceAsyncProcessor::setUpAndProcess_getSpace}, + {"listSpaces", &MetaServiceAsyncProcessor::setUpAndProcess_listSpaces}, + {"createSpaceAs", &MetaServiceAsyncProcessor::setUpAndProcess_createSpaceAs}, + {"createTag", &MetaServiceAsyncProcessor::setUpAndProcess_createTag}, + {"alterTag", &MetaServiceAsyncProcessor::setUpAndProcess_alterTag}, + {"dropTag", &MetaServiceAsyncProcessor::setUpAndProcess_dropTag}, + {"getTag", &MetaServiceAsyncProcessor::setUpAndProcess_getTag}, + {"listTags", &MetaServiceAsyncProcessor::setUpAndProcess_listTags}, + {"createEdge", &MetaServiceAsyncProcessor::setUpAndProcess_createEdge}, + {"alterEdge", &MetaServiceAsyncProcessor::setUpAndProcess_alterEdge}, + {"dropEdge", &MetaServiceAsyncProcessor::setUpAndProcess_dropEdge}, + {"getEdge", &MetaServiceAsyncProcessor::setUpAndProcess_getEdge}, + {"listEdges", &MetaServiceAsyncProcessor::setUpAndProcess_listEdges}, + {"listHosts", &MetaServiceAsyncProcessor::setUpAndProcess_listHosts}, + {"getPartsAlloc", &MetaServiceAsyncProcessor::setUpAndProcess_getPartsAlloc}, + {"listParts", &MetaServiceAsyncProcessor::setUpAndProcess_listParts}, + {"multiPut", &MetaServiceAsyncProcessor::setUpAndProcess_multiPut}, + {"get", &MetaServiceAsyncProcessor::setUpAndProcess_get}, + {"multiGet", &MetaServiceAsyncProcessor::setUpAndProcess_multiGet}, + {"remove", &MetaServiceAsyncProcessor::setUpAndProcess_remove}, + {"removeRange", &MetaServiceAsyncProcessor::setUpAndProcess_removeRange}, + {"scan", &MetaServiceAsyncProcessor::setUpAndProcess_scan}, + {"createTagIndex", &MetaServiceAsyncProcessor::setUpAndProcess_createTagIndex}, + {"dropTagIndex", &MetaServiceAsyncProcessor::setUpAndProcess_dropTagIndex}, + {"getTagIndex", &MetaServiceAsyncProcessor::setUpAndProcess_getTagIndex}, + {"listTagIndexes", &MetaServiceAsyncProcessor::setUpAndProcess_listTagIndexes}, + {"rebuildTagIndex", &MetaServiceAsyncProcessor::setUpAndProcess_rebuildTagIndex}, + {"listTagIndexStatus", &MetaServiceAsyncProcessor::setUpAndProcess_listTagIndexStatus}, + {"createEdgeIndex", &MetaServiceAsyncProcessor::setUpAndProcess_createEdgeIndex}, + {"dropEdgeIndex", &MetaServiceAsyncProcessor::setUpAndProcess_dropEdgeIndex}, + {"getEdgeIndex", &MetaServiceAsyncProcessor::setUpAndProcess_getEdgeIndex}, + {"listEdgeIndexes", &MetaServiceAsyncProcessor::setUpAndProcess_listEdgeIndexes}, + {"rebuildEdgeIndex", &MetaServiceAsyncProcessor::setUpAndProcess_rebuildEdgeIndex}, + {"listEdgeIndexStatus", &MetaServiceAsyncProcessor::setUpAndProcess_listEdgeIndexStatus}, + {"createUser", &MetaServiceAsyncProcessor::setUpAndProcess_createUser}, + {"dropUser", &MetaServiceAsyncProcessor::setUpAndProcess_dropUser}, + {"alterUser", &MetaServiceAsyncProcessor::setUpAndProcess_alterUser}, + {"grantRole", &MetaServiceAsyncProcessor::setUpAndProcess_grantRole}, + {"revokeRole", &MetaServiceAsyncProcessor::setUpAndProcess_revokeRole}, + {"listUsers", &MetaServiceAsyncProcessor::setUpAndProcess_listUsers}, + {"listRoles", &MetaServiceAsyncProcessor::setUpAndProcess_listRoles}, + {"getUserRoles", &MetaServiceAsyncProcessor::setUpAndProcess_getUserRoles}, + {"changePassword", &MetaServiceAsyncProcessor::setUpAndProcess_changePassword}, + {"heartBeat", &MetaServiceAsyncProcessor::setUpAndProcess_heartBeat}, + {"balance", &MetaServiceAsyncProcessor::setUpAndProcess_balance}, + {"leaderBalance", &MetaServiceAsyncProcessor::setUpAndProcess_leaderBalance}, + {"regConfig", &MetaServiceAsyncProcessor::setUpAndProcess_regConfig}, + {"getConfig", &MetaServiceAsyncProcessor::setUpAndProcess_getConfig}, + {"setConfig", &MetaServiceAsyncProcessor::setUpAndProcess_setConfig}, + {"listConfigs", &MetaServiceAsyncProcessor::setUpAndProcess_listConfigs}, + {"createSnapshot", &MetaServiceAsyncProcessor::setUpAndProcess_createSnapshot}, + {"dropSnapshot", &MetaServiceAsyncProcessor::setUpAndProcess_dropSnapshot}, + {"listSnapshots", &MetaServiceAsyncProcessor::setUpAndProcess_listSnapshots}, + {"runAdminJob", &MetaServiceAsyncProcessor::setUpAndProcess_runAdminJob}, + {"addZone", &MetaServiceAsyncProcessor::setUpAndProcess_addZone}, + {"dropZone", &MetaServiceAsyncProcessor::setUpAndProcess_dropZone}, + {"addHostIntoZone", &MetaServiceAsyncProcessor::setUpAndProcess_addHostIntoZone}, + {"dropHostFromZone", &MetaServiceAsyncProcessor::setUpAndProcess_dropHostFromZone}, + {"getZone", &MetaServiceAsyncProcessor::setUpAndProcess_getZone}, + {"listZones", &MetaServiceAsyncProcessor::setUpAndProcess_listZones}, + {"addGroup", &MetaServiceAsyncProcessor::setUpAndProcess_addGroup}, + {"dropGroup", &MetaServiceAsyncProcessor::setUpAndProcess_dropGroup}, + {"addZoneIntoGroup", &MetaServiceAsyncProcessor::setUpAndProcess_addZoneIntoGroup}, + {"dropZoneFromGroup", &MetaServiceAsyncProcessor::setUpAndProcess_dropZoneFromGroup}, + {"getGroup", &MetaServiceAsyncProcessor::setUpAndProcess_getGroup}, + {"listGroups", &MetaServiceAsyncProcessor::setUpAndProcess_listGroups}, + {"createBackup", &MetaServiceAsyncProcessor::setUpAndProcess_createBackup}, + {"restoreMeta", &MetaServiceAsyncProcessor::setUpAndProcess_restoreMeta}, + {"addListener", &MetaServiceAsyncProcessor::setUpAndProcess_addListener}, + {"removeListener", &MetaServiceAsyncProcessor::setUpAndProcess_removeListener}, + {"listListener", &MetaServiceAsyncProcessor::setUpAndProcess_listListener}, + {"getStats", &MetaServiceAsyncProcessor::setUpAndProcess_getStats}, + {"signInFTService", &MetaServiceAsyncProcessor::setUpAndProcess_signInFTService}, + {"signOutFTService", &MetaServiceAsyncProcessor::setUpAndProcess_signOutFTService}, + {"listFTClients", &MetaServiceAsyncProcessor::setUpAndProcess_listFTClients}, + {"createFTIndex", &MetaServiceAsyncProcessor::setUpAndProcess_createFTIndex}, + {"dropFTIndex", &MetaServiceAsyncProcessor::setUpAndProcess_dropFTIndex}, + {"listFTIndexes", &MetaServiceAsyncProcessor::setUpAndProcess_listFTIndexes}, + {"createSession", &MetaServiceAsyncProcessor::setUpAndProcess_createSession}, + {"updateSessions", &MetaServiceAsyncProcessor::setUpAndProcess_updateSessions}, + {"listSessions", &MetaServiceAsyncProcessor::setUpAndProcess_listSessions}, + {"getSession", &MetaServiceAsyncProcessor::setUpAndProcess_getSession}, + {"removeSession", &MetaServiceAsyncProcessor::setUpAndProcess_removeSession}, + {"killQuery", &MetaServiceAsyncProcessor::setUpAndProcess_killQuery}, + {"reportTaskFinish", &MetaServiceAsyncProcessor::setUpAndProcess_reportTaskFinish}, + {"listCluster", &MetaServiceAsyncProcessor::setUpAndProcess_listCluster}, + {"getMetaDirInfo", &MetaServiceAsyncProcessor::setUpAndProcess_getMetaDirInfo}, + {"verifyClientVersion", &MetaServiceAsyncProcessor::setUpAndProcess_verifyClientVersion}, +}; + +const MetaServiceAsyncProcessor::ProcessMap& MetaServiceAsyncProcessor::getCompactProtocolProcessMap() { + return compactProcessMap_; +} + +const MetaServiceAsyncProcessor::ProcessMap MetaServiceAsyncProcessor::compactProcessMap_ { + {"createSpace", &MetaServiceAsyncProcessor::setUpAndProcess_createSpace}, + {"dropSpace", &MetaServiceAsyncProcessor::setUpAndProcess_dropSpace}, + {"getSpace", &MetaServiceAsyncProcessor::setUpAndProcess_getSpace}, + {"listSpaces", &MetaServiceAsyncProcessor::setUpAndProcess_listSpaces}, + {"createSpaceAs", &MetaServiceAsyncProcessor::setUpAndProcess_createSpaceAs}, + {"createTag", &MetaServiceAsyncProcessor::setUpAndProcess_createTag}, + {"alterTag", &MetaServiceAsyncProcessor::setUpAndProcess_alterTag}, + {"dropTag", &MetaServiceAsyncProcessor::setUpAndProcess_dropTag}, + {"getTag", &MetaServiceAsyncProcessor::setUpAndProcess_getTag}, + {"listTags", &MetaServiceAsyncProcessor::setUpAndProcess_listTags}, + {"createEdge", &MetaServiceAsyncProcessor::setUpAndProcess_createEdge}, + {"alterEdge", &MetaServiceAsyncProcessor::setUpAndProcess_alterEdge}, + {"dropEdge", &MetaServiceAsyncProcessor::setUpAndProcess_dropEdge}, + {"getEdge", &MetaServiceAsyncProcessor::setUpAndProcess_getEdge}, + {"listEdges", &MetaServiceAsyncProcessor::setUpAndProcess_listEdges}, + {"listHosts", &MetaServiceAsyncProcessor::setUpAndProcess_listHosts}, + {"getPartsAlloc", &MetaServiceAsyncProcessor::setUpAndProcess_getPartsAlloc}, + {"listParts", &MetaServiceAsyncProcessor::setUpAndProcess_listParts}, + {"multiPut", &MetaServiceAsyncProcessor::setUpAndProcess_multiPut}, + {"get", &MetaServiceAsyncProcessor::setUpAndProcess_get}, + {"multiGet", &MetaServiceAsyncProcessor::setUpAndProcess_multiGet}, + {"remove", &MetaServiceAsyncProcessor::setUpAndProcess_remove}, + {"removeRange", &MetaServiceAsyncProcessor::setUpAndProcess_removeRange}, + {"scan", &MetaServiceAsyncProcessor::setUpAndProcess_scan}, + {"createTagIndex", &MetaServiceAsyncProcessor::setUpAndProcess_createTagIndex}, + {"dropTagIndex", &MetaServiceAsyncProcessor::setUpAndProcess_dropTagIndex}, + {"getTagIndex", &MetaServiceAsyncProcessor::setUpAndProcess_getTagIndex}, + {"listTagIndexes", &MetaServiceAsyncProcessor::setUpAndProcess_listTagIndexes}, + {"rebuildTagIndex", &MetaServiceAsyncProcessor::setUpAndProcess_rebuildTagIndex}, + {"listTagIndexStatus", &MetaServiceAsyncProcessor::setUpAndProcess_listTagIndexStatus}, + {"createEdgeIndex", &MetaServiceAsyncProcessor::setUpAndProcess_createEdgeIndex}, + {"dropEdgeIndex", &MetaServiceAsyncProcessor::setUpAndProcess_dropEdgeIndex}, + {"getEdgeIndex", &MetaServiceAsyncProcessor::setUpAndProcess_getEdgeIndex}, + {"listEdgeIndexes", &MetaServiceAsyncProcessor::setUpAndProcess_listEdgeIndexes}, + {"rebuildEdgeIndex", &MetaServiceAsyncProcessor::setUpAndProcess_rebuildEdgeIndex}, + {"listEdgeIndexStatus", &MetaServiceAsyncProcessor::setUpAndProcess_listEdgeIndexStatus}, + {"createUser", &MetaServiceAsyncProcessor::setUpAndProcess_createUser}, + {"dropUser", &MetaServiceAsyncProcessor::setUpAndProcess_dropUser}, + {"alterUser", &MetaServiceAsyncProcessor::setUpAndProcess_alterUser}, + {"grantRole", &MetaServiceAsyncProcessor::setUpAndProcess_grantRole}, + {"revokeRole", &MetaServiceAsyncProcessor::setUpAndProcess_revokeRole}, + {"listUsers", &MetaServiceAsyncProcessor::setUpAndProcess_listUsers}, + {"listRoles", &MetaServiceAsyncProcessor::setUpAndProcess_listRoles}, + {"getUserRoles", &MetaServiceAsyncProcessor::setUpAndProcess_getUserRoles}, + {"changePassword", &MetaServiceAsyncProcessor::setUpAndProcess_changePassword}, + {"heartBeat", &MetaServiceAsyncProcessor::setUpAndProcess_heartBeat}, + {"balance", &MetaServiceAsyncProcessor::setUpAndProcess_balance}, + {"leaderBalance", &MetaServiceAsyncProcessor::setUpAndProcess_leaderBalance}, + {"regConfig", &MetaServiceAsyncProcessor::setUpAndProcess_regConfig}, + {"getConfig", &MetaServiceAsyncProcessor::setUpAndProcess_getConfig}, + {"setConfig", &MetaServiceAsyncProcessor::setUpAndProcess_setConfig}, + {"listConfigs", &MetaServiceAsyncProcessor::setUpAndProcess_listConfigs}, + {"createSnapshot", &MetaServiceAsyncProcessor::setUpAndProcess_createSnapshot}, + {"dropSnapshot", &MetaServiceAsyncProcessor::setUpAndProcess_dropSnapshot}, + {"listSnapshots", &MetaServiceAsyncProcessor::setUpAndProcess_listSnapshots}, + {"runAdminJob", &MetaServiceAsyncProcessor::setUpAndProcess_runAdminJob}, + {"addZone", &MetaServiceAsyncProcessor::setUpAndProcess_addZone}, + {"dropZone", &MetaServiceAsyncProcessor::setUpAndProcess_dropZone}, + {"addHostIntoZone", &MetaServiceAsyncProcessor::setUpAndProcess_addHostIntoZone}, + {"dropHostFromZone", &MetaServiceAsyncProcessor::setUpAndProcess_dropHostFromZone}, + {"getZone", &MetaServiceAsyncProcessor::setUpAndProcess_getZone}, + {"listZones", &MetaServiceAsyncProcessor::setUpAndProcess_listZones}, + {"addGroup", &MetaServiceAsyncProcessor::setUpAndProcess_addGroup}, + {"dropGroup", &MetaServiceAsyncProcessor::setUpAndProcess_dropGroup}, + {"addZoneIntoGroup", &MetaServiceAsyncProcessor::setUpAndProcess_addZoneIntoGroup}, + {"dropZoneFromGroup", &MetaServiceAsyncProcessor::setUpAndProcess_dropZoneFromGroup}, + {"getGroup", &MetaServiceAsyncProcessor::setUpAndProcess_getGroup}, + {"listGroups", &MetaServiceAsyncProcessor::setUpAndProcess_listGroups}, + {"createBackup", &MetaServiceAsyncProcessor::setUpAndProcess_createBackup}, + {"restoreMeta", &MetaServiceAsyncProcessor::setUpAndProcess_restoreMeta}, + {"addListener", &MetaServiceAsyncProcessor::setUpAndProcess_addListener}, + {"removeListener", &MetaServiceAsyncProcessor::setUpAndProcess_removeListener}, + {"listListener", &MetaServiceAsyncProcessor::setUpAndProcess_listListener}, + {"getStats", &MetaServiceAsyncProcessor::setUpAndProcess_getStats}, + {"signInFTService", &MetaServiceAsyncProcessor::setUpAndProcess_signInFTService}, + {"signOutFTService", &MetaServiceAsyncProcessor::setUpAndProcess_signOutFTService}, + {"listFTClients", &MetaServiceAsyncProcessor::setUpAndProcess_listFTClients}, + {"createFTIndex", &MetaServiceAsyncProcessor::setUpAndProcess_createFTIndex}, + {"dropFTIndex", &MetaServiceAsyncProcessor::setUpAndProcess_dropFTIndex}, + {"listFTIndexes", &MetaServiceAsyncProcessor::setUpAndProcess_listFTIndexes}, + {"createSession", &MetaServiceAsyncProcessor::setUpAndProcess_createSession}, + {"updateSessions", &MetaServiceAsyncProcessor::setUpAndProcess_updateSessions}, + {"listSessions", &MetaServiceAsyncProcessor::setUpAndProcess_listSessions}, + {"getSession", &MetaServiceAsyncProcessor::setUpAndProcess_getSession}, + {"removeSession", &MetaServiceAsyncProcessor::setUpAndProcess_removeSession}, + {"killQuery", &MetaServiceAsyncProcessor::setUpAndProcess_killQuery}, + {"reportTaskFinish", &MetaServiceAsyncProcessor::setUpAndProcess_reportTaskFinish}, + {"listCluster", &MetaServiceAsyncProcessor::setUpAndProcess_listCluster}, + {"getMetaDirInfo", &MetaServiceAsyncProcessor::setUpAndProcess_getMetaDirInfo}, + {"verifyClientVersion", &MetaServiceAsyncProcessor::setUpAndProcess_verifyClientVersion}, +}; + +}}} // nebula::meta::cpp2 diff --git a/src/interface/gen-cpp2/MetaService.h b/src/interface/gen-cpp2/MetaService.h new file mode 100644 index 00000000..70d88681 --- /dev/null +++ b/src/interface/gen-cpp2/MetaService.h @@ -0,0 +1,1514 @@ +/** + * Autogenerated by Thrift for meta.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#pragma once + +#include + +#include "MetaServiceAsyncClient.h" +#include "meta_types.h" +#include "common_types.h" + +namespace folly { + class IOBuf; + class IOBufQueue; +} +namespace apache { namespace thrift { + class Cpp2RequestContext; + class BinaryProtocolReader; + class CompactProtocolReader; + namespace transport { class THeader; } +}} + +namespace nebula { namespace meta { namespace cpp2 { + +class MetaServiceSvAsyncIf { + public: + virtual ~MetaServiceSvAsyncIf() {} + virtual void async_tm_createSpace(std::unique_ptr> callback, const ::nebula::meta::cpp2::CreateSpaceReq& p_req) = 0; + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_createSpace(const ::nebula::meta::cpp2::CreateSpaceReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_createSpace(const ::nebula::meta::cpp2::CreateSpaceReq& p_req) = 0; + virtual void async_tm_dropSpace(std::unique_ptr> callback, const ::nebula::meta::cpp2::DropSpaceReq& p_req) = 0; + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_dropSpace(const ::nebula::meta::cpp2::DropSpaceReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_dropSpace(const ::nebula::meta::cpp2::DropSpaceReq& p_req) = 0; + virtual void async_tm_getSpace(std::unique_ptr> callback, const ::nebula::meta::cpp2::GetSpaceReq& p_req) = 0; + virtual folly::Future< ::nebula::meta::cpp2::GetSpaceResp> future_getSpace(const ::nebula::meta::cpp2::GetSpaceReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::meta::cpp2::GetSpaceResp> semifuture_getSpace(const ::nebula::meta::cpp2::GetSpaceReq& p_req) = 0; + virtual void async_tm_listSpaces(std::unique_ptr> callback, const ::nebula::meta::cpp2::ListSpacesReq& p_req) = 0; + virtual folly::Future< ::nebula::meta::cpp2::ListSpacesResp> future_listSpaces(const ::nebula::meta::cpp2::ListSpacesReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::meta::cpp2::ListSpacesResp> semifuture_listSpaces(const ::nebula::meta::cpp2::ListSpacesReq& p_req) = 0; + virtual void async_tm_createSpaceAs(std::unique_ptr> callback, const ::nebula::meta::cpp2::CreateSpaceAsReq& p_req) = 0; + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_createSpaceAs(const ::nebula::meta::cpp2::CreateSpaceAsReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_createSpaceAs(const ::nebula::meta::cpp2::CreateSpaceAsReq& p_req) = 0; + virtual void async_tm_createTag(std::unique_ptr> callback, const ::nebula::meta::cpp2::CreateTagReq& p_req) = 0; + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_createTag(const ::nebula::meta::cpp2::CreateTagReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_createTag(const ::nebula::meta::cpp2::CreateTagReq& p_req) = 0; + virtual void async_tm_alterTag(std::unique_ptr> callback, const ::nebula::meta::cpp2::AlterTagReq& p_req) = 0; + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_alterTag(const ::nebula::meta::cpp2::AlterTagReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_alterTag(const ::nebula::meta::cpp2::AlterTagReq& p_req) = 0; + virtual void async_tm_dropTag(std::unique_ptr> callback, const ::nebula::meta::cpp2::DropTagReq& p_req) = 0; + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_dropTag(const ::nebula::meta::cpp2::DropTagReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_dropTag(const ::nebula::meta::cpp2::DropTagReq& p_req) = 0; + virtual void async_tm_getTag(std::unique_ptr> callback, const ::nebula::meta::cpp2::GetTagReq& p_req) = 0; + virtual folly::Future< ::nebula::meta::cpp2::GetTagResp> future_getTag(const ::nebula::meta::cpp2::GetTagReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::meta::cpp2::GetTagResp> semifuture_getTag(const ::nebula::meta::cpp2::GetTagReq& p_req) = 0; + virtual void async_tm_listTags(std::unique_ptr> callback, const ::nebula::meta::cpp2::ListTagsReq& p_req) = 0; + virtual folly::Future< ::nebula::meta::cpp2::ListTagsResp> future_listTags(const ::nebula::meta::cpp2::ListTagsReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::meta::cpp2::ListTagsResp> semifuture_listTags(const ::nebula::meta::cpp2::ListTagsReq& p_req) = 0; + virtual void async_tm_createEdge(std::unique_ptr> callback, const ::nebula::meta::cpp2::CreateEdgeReq& p_req) = 0; + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_createEdge(const ::nebula::meta::cpp2::CreateEdgeReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_createEdge(const ::nebula::meta::cpp2::CreateEdgeReq& p_req) = 0; + virtual void async_tm_alterEdge(std::unique_ptr> callback, const ::nebula::meta::cpp2::AlterEdgeReq& p_req) = 0; + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_alterEdge(const ::nebula::meta::cpp2::AlterEdgeReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_alterEdge(const ::nebula::meta::cpp2::AlterEdgeReq& p_req) = 0; + virtual void async_tm_dropEdge(std::unique_ptr> callback, const ::nebula::meta::cpp2::DropEdgeReq& p_req) = 0; + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_dropEdge(const ::nebula::meta::cpp2::DropEdgeReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_dropEdge(const ::nebula::meta::cpp2::DropEdgeReq& p_req) = 0; + virtual void async_tm_getEdge(std::unique_ptr> callback, const ::nebula::meta::cpp2::GetEdgeReq& p_req) = 0; + virtual folly::Future< ::nebula::meta::cpp2::GetEdgeResp> future_getEdge(const ::nebula::meta::cpp2::GetEdgeReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::meta::cpp2::GetEdgeResp> semifuture_getEdge(const ::nebula::meta::cpp2::GetEdgeReq& p_req) = 0; + virtual void async_tm_listEdges(std::unique_ptr> callback, const ::nebula::meta::cpp2::ListEdgesReq& p_req) = 0; + virtual folly::Future< ::nebula::meta::cpp2::ListEdgesResp> future_listEdges(const ::nebula::meta::cpp2::ListEdgesReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::meta::cpp2::ListEdgesResp> semifuture_listEdges(const ::nebula::meta::cpp2::ListEdgesReq& p_req) = 0; + virtual void async_tm_listHosts(std::unique_ptr> callback, const ::nebula::meta::cpp2::ListHostsReq& p_req) = 0; + virtual folly::Future< ::nebula::meta::cpp2::ListHostsResp> future_listHosts(const ::nebula::meta::cpp2::ListHostsReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::meta::cpp2::ListHostsResp> semifuture_listHosts(const ::nebula::meta::cpp2::ListHostsReq& p_req) = 0; + virtual void async_tm_getPartsAlloc(std::unique_ptr> callback, const ::nebula::meta::cpp2::GetPartsAllocReq& p_req) = 0; + virtual folly::Future< ::nebula::meta::cpp2::GetPartsAllocResp> future_getPartsAlloc(const ::nebula::meta::cpp2::GetPartsAllocReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::meta::cpp2::GetPartsAllocResp> semifuture_getPartsAlloc(const ::nebula::meta::cpp2::GetPartsAllocReq& p_req) = 0; + virtual void async_tm_listParts(std::unique_ptr> callback, const ::nebula::meta::cpp2::ListPartsReq& p_req) = 0; + virtual folly::Future< ::nebula::meta::cpp2::ListPartsResp> future_listParts(const ::nebula::meta::cpp2::ListPartsReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::meta::cpp2::ListPartsResp> semifuture_listParts(const ::nebula::meta::cpp2::ListPartsReq& p_req) = 0; + virtual void async_tm_multiPut(std::unique_ptr> callback, const ::nebula::meta::cpp2::MultiPutReq& p_req) = 0; + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_multiPut(const ::nebula::meta::cpp2::MultiPutReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_multiPut(const ::nebula::meta::cpp2::MultiPutReq& p_req) = 0; + virtual void async_tm_get(std::unique_ptr> callback, const ::nebula::meta::cpp2::GetReq& p_req) = 0; + virtual folly::Future< ::nebula::meta::cpp2::GetResp> future_get(const ::nebula::meta::cpp2::GetReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::meta::cpp2::GetResp> semifuture_get(const ::nebula::meta::cpp2::GetReq& p_req) = 0; + virtual void async_tm_multiGet(std::unique_ptr> callback, const ::nebula::meta::cpp2::MultiGetReq& p_req) = 0; + virtual folly::Future< ::nebula::meta::cpp2::MultiGetResp> future_multiGet(const ::nebula::meta::cpp2::MultiGetReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::meta::cpp2::MultiGetResp> semifuture_multiGet(const ::nebula::meta::cpp2::MultiGetReq& p_req) = 0; + virtual void async_tm_remove(std::unique_ptr> callback, const ::nebula::meta::cpp2::RemoveReq& p_req) = 0; + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_remove(const ::nebula::meta::cpp2::RemoveReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_remove(const ::nebula::meta::cpp2::RemoveReq& p_req) = 0; + virtual void async_tm_removeRange(std::unique_ptr> callback, const ::nebula::meta::cpp2::RemoveRangeReq& p_req) = 0; + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_removeRange(const ::nebula::meta::cpp2::RemoveRangeReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_removeRange(const ::nebula::meta::cpp2::RemoveRangeReq& p_req) = 0; + virtual void async_tm_scan(std::unique_ptr> callback, const ::nebula::meta::cpp2::ScanReq& p_req) = 0; + virtual folly::Future< ::nebula::meta::cpp2::ScanResp> future_scan(const ::nebula::meta::cpp2::ScanReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::meta::cpp2::ScanResp> semifuture_scan(const ::nebula::meta::cpp2::ScanReq& p_req) = 0; + virtual void async_tm_createTagIndex(std::unique_ptr> callback, const ::nebula::meta::cpp2::CreateTagIndexReq& p_req) = 0; + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_createTagIndex(const ::nebula::meta::cpp2::CreateTagIndexReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_createTagIndex(const ::nebula::meta::cpp2::CreateTagIndexReq& p_req) = 0; + virtual void async_tm_dropTagIndex(std::unique_ptr> callback, const ::nebula::meta::cpp2::DropTagIndexReq& p_req) = 0; + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_dropTagIndex(const ::nebula::meta::cpp2::DropTagIndexReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_dropTagIndex(const ::nebula::meta::cpp2::DropTagIndexReq& p_req) = 0; + virtual void async_tm_getTagIndex(std::unique_ptr> callback, const ::nebula::meta::cpp2::GetTagIndexReq& p_req) = 0; + virtual folly::Future< ::nebula::meta::cpp2::GetTagIndexResp> future_getTagIndex(const ::nebula::meta::cpp2::GetTagIndexReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::meta::cpp2::GetTagIndexResp> semifuture_getTagIndex(const ::nebula::meta::cpp2::GetTagIndexReq& p_req) = 0; + virtual void async_tm_listTagIndexes(std::unique_ptr> callback, const ::nebula::meta::cpp2::ListTagIndexesReq& p_req) = 0; + virtual folly::Future< ::nebula::meta::cpp2::ListTagIndexesResp> future_listTagIndexes(const ::nebula::meta::cpp2::ListTagIndexesReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::meta::cpp2::ListTagIndexesResp> semifuture_listTagIndexes(const ::nebula::meta::cpp2::ListTagIndexesReq& p_req) = 0; + virtual void async_tm_rebuildTagIndex(std::unique_ptr> callback, const ::nebula::meta::cpp2::RebuildIndexReq& p_req) = 0; + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_rebuildTagIndex(const ::nebula::meta::cpp2::RebuildIndexReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_rebuildTagIndex(const ::nebula::meta::cpp2::RebuildIndexReq& p_req) = 0; + virtual void async_tm_listTagIndexStatus(std::unique_ptr> callback, const ::nebula::meta::cpp2::ListIndexStatusReq& p_req) = 0; + virtual folly::Future< ::nebula::meta::cpp2::ListIndexStatusResp> future_listTagIndexStatus(const ::nebula::meta::cpp2::ListIndexStatusReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::meta::cpp2::ListIndexStatusResp> semifuture_listTagIndexStatus(const ::nebula::meta::cpp2::ListIndexStatusReq& p_req) = 0; + virtual void async_tm_createEdgeIndex(std::unique_ptr> callback, const ::nebula::meta::cpp2::CreateEdgeIndexReq& p_req) = 0; + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_createEdgeIndex(const ::nebula::meta::cpp2::CreateEdgeIndexReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_createEdgeIndex(const ::nebula::meta::cpp2::CreateEdgeIndexReq& p_req) = 0; + virtual void async_tm_dropEdgeIndex(std::unique_ptr> callback, const ::nebula::meta::cpp2::DropEdgeIndexReq& p_req) = 0; + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_dropEdgeIndex(const ::nebula::meta::cpp2::DropEdgeIndexReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_dropEdgeIndex(const ::nebula::meta::cpp2::DropEdgeIndexReq& p_req) = 0; + virtual void async_tm_getEdgeIndex(std::unique_ptr> callback, const ::nebula::meta::cpp2::GetEdgeIndexReq& p_req) = 0; + virtual folly::Future< ::nebula::meta::cpp2::GetEdgeIndexResp> future_getEdgeIndex(const ::nebula::meta::cpp2::GetEdgeIndexReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::meta::cpp2::GetEdgeIndexResp> semifuture_getEdgeIndex(const ::nebula::meta::cpp2::GetEdgeIndexReq& p_req) = 0; + virtual void async_tm_listEdgeIndexes(std::unique_ptr> callback, const ::nebula::meta::cpp2::ListEdgeIndexesReq& p_req) = 0; + virtual folly::Future< ::nebula::meta::cpp2::ListEdgeIndexesResp> future_listEdgeIndexes(const ::nebula::meta::cpp2::ListEdgeIndexesReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::meta::cpp2::ListEdgeIndexesResp> semifuture_listEdgeIndexes(const ::nebula::meta::cpp2::ListEdgeIndexesReq& p_req) = 0; + virtual void async_tm_rebuildEdgeIndex(std::unique_ptr> callback, const ::nebula::meta::cpp2::RebuildIndexReq& p_req) = 0; + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_rebuildEdgeIndex(const ::nebula::meta::cpp2::RebuildIndexReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_rebuildEdgeIndex(const ::nebula::meta::cpp2::RebuildIndexReq& p_req) = 0; + virtual void async_tm_listEdgeIndexStatus(std::unique_ptr> callback, const ::nebula::meta::cpp2::ListIndexStatusReq& p_req) = 0; + virtual folly::Future< ::nebula::meta::cpp2::ListIndexStatusResp> future_listEdgeIndexStatus(const ::nebula::meta::cpp2::ListIndexStatusReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::meta::cpp2::ListIndexStatusResp> semifuture_listEdgeIndexStatus(const ::nebula::meta::cpp2::ListIndexStatusReq& p_req) = 0; + virtual void async_tm_createUser(std::unique_ptr> callback, const ::nebula::meta::cpp2::CreateUserReq& p_req) = 0; + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_createUser(const ::nebula::meta::cpp2::CreateUserReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_createUser(const ::nebula::meta::cpp2::CreateUserReq& p_req) = 0; + virtual void async_tm_dropUser(std::unique_ptr> callback, const ::nebula::meta::cpp2::DropUserReq& p_req) = 0; + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_dropUser(const ::nebula::meta::cpp2::DropUserReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_dropUser(const ::nebula::meta::cpp2::DropUserReq& p_req) = 0; + virtual void async_tm_alterUser(std::unique_ptr> callback, const ::nebula::meta::cpp2::AlterUserReq& p_req) = 0; + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_alterUser(const ::nebula::meta::cpp2::AlterUserReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_alterUser(const ::nebula::meta::cpp2::AlterUserReq& p_req) = 0; + virtual void async_tm_grantRole(std::unique_ptr> callback, const ::nebula::meta::cpp2::GrantRoleReq& p_req) = 0; + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_grantRole(const ::nebula::meta::cpp2::GrantRoleReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_grantRole(const ::nebula::meta::cpp2::GrantRoleReq& p_req) = 0; + virtual void async_tm_revokeRole(std::unique_ptr> callback, const ::nebula::meta::cpp2::RevokeRoleReq& p_req) = 0; + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_revokeRole(const ::nebula::meta::cpp2::RevokeRoleReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_revokeRole(const ::nebula::meta::cpp2::RevokeRoleReq& p_req) = 0; + virtual void async_tm_listUsers(std::unique_ptr> callback, const ::nebula::meta::cpp2::ListUsersReq& p_req) = 0; + virtual folly::Future< ::nebula::meta::cpp2::ListUsersResp> future_listUsers(const ::nebula::meta::cpp2::ListUsersReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::meta::cpp2::ListUsersResp> semifuture_listUsers(const ::nebula::meta::cpp2::ListUsersReq& p_req) = 0; + virtual void async_tm_listRoles(std::unique_ptr> callback, const ::nebula::meta::cpp2::ListRolesReq& p_req) = 0; + virtual folly::Future< ::nebula::meta::cpp2::ListRolesResp> future_listRoles(const ::nebula::meta::cpp2::ListRolesReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::meta::cpp2::ListRolesResp> semifuture_listRoles(const ::nebula::meta::cpp2::ListRolesReq& p_req) = 0; + virtual void async_tm_getUserRoles(std::unique_ptr> callback, const ::nebula::meta::cpp2::GetUserRolesReq& p_req) = 0; + virtual folly::Future< ::nebula::meta::cpp2::ListRolesResp> future_getUserRoles(const ::nebula::meta::cpp2::GetUserRolesReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::meta::cpp2::ListRolesResp> semifuture_getUserRoles(const ::nebula::meta::cpp2::GetUserRolesReq& p_req) = 0; + virtual void async_tm_changePassword(std::unique_ptr> callback, const ::nebula::meta::cpp2::ChangePasswordReq& p_req) = 0; + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_changePassword(const ::nebula::meta::cpp2::ChangePasswordReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_changePassword(const ::nebula::meta::cpp2::ChangePasswordReq& p_req) = 0; + virtual void async_tm_heartBeat(std::unique_ptr> callback, const ::nebula::meta::cpp2::HBReq& p_req) = 0; + virtual folly::Future< ::nebula::meta::cpp2::HBResp> future_heartBeat(const ::nebula::meta::cpp2::HBReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::meta::cpp2::HBResp> semifuture_heartBeat(const ::nebula::meta::cpp2::HBReq& p_req) = 0; + virtual void async_tm_balance(std::unique_ptr> callback, const ::nebula::meta::cpp2::BalanceReq& p_req) = 0; + virtual folly::Future< ::nebula::meta::cpp2::BalanceResp> future_balance(const ::nebula::meta::cpp2::BalanceReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::meta::cpp2::BalanceResp> semifuture_balance(const ::nebula::meta::cpp2::BalanceReq& p_req) = 0; + virtual void async_tm_leaderBalance(std::unique_ptr> callback, const ::nebula::meta::cpp2::LeaderBalanceReq& p_req) = 0; + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_leaderBalance(const ::nebula::meta::cpp2::LeaderBalanceReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_leaderBalance(const ::nebula::meta::cpp2::LeaderBalanceReq& p_req) = 0; + virtual void async_tm_regConfig(std::unique_ptr> callback, const ::nebula::meta::cpp2::RegConfigReq& p_req) = 0; + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_regConfig(const ::nebula::meta::cpp2::RegConfigReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_regConfig(const ::nebula::meta::cpp2::RegConfigReq& p_req) = 0; + virtual void async_tm_getConfig(std::unique_ptr> callback, const ::nebula::meta::cpp2::GetConfigReq& p_req) = 0; + virtual folly::Future< ::nebula::meta::cpp2::GetConfigResp> future_getConfig(const ::nebula::meta::cpp2::GetConfigReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::meta::cpp2::GetConfigResp> semifuture_getConfig(const ::nebula::meta::cpp2::GetConfigReq& p_req) = 0; + virtual void async_tm_setConfig(std::unique_ptr> callback, const ::nebula::meta::cpp2::SetConfigReq& p_req) = 0; + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_setConfig(const ::nebula::meta::cpp2::SetConfigReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_setConfig(const ::nebula::meta::cpp2::SetConfigReq& p_req) = 0; + virtual void async_tm_listConfigs(std::unique_ptr> callback, const ::nebula::meta::cpp2::ListConfigsReq& p_req) = 0; + virtual folly::Future< ::nebula::meta::cpp2::ListConfigsResp> future_listConfigs(const ::nebula::meta::cpp2::ListConfigsReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::meta::cpp2::ListConfigsResp> semifuture_listConfigs(const ::nebula::meta::cpp2::ListConfigsReq& p_req) = 0; + virtual void async_tm_createSnapshot(std::unique_ptr> callback, const ::nebula::meta::cpp2::CreateSnapshotReq& p_req) = 0; + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_createSnapshot(const ::nebula::meta::cpp2::CreateSnapshotReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_createSnapshot(const ::nebula::meta::cpp2::CreateSnapshotReq& p_req) = 0; + virtual void async_tm_dropSnapshot(std::unique_ptr> callback, const ::nebula::meta::cpp2::DropSnapshotReq& p_req) = 0; + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_dropSnapshot(const ::nebula::meta::cpp2::DropSnapshotReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_dropSnapshot(const ::nebula::meta::cpp2::DropSnapshotReq& p_req) = 0; + virtual void async_tm_listSnapshots(std::unique_ptr> callback, const ::nebula::meta::cpp2::ListSnapshotsReq& p_req) = 0; + virtual folly::Future< ::nebula::meta::cpp2::ListSnapshotsResp> future_listSnapshots(const ::nebula::meta::cpp2::ListSnapshotsReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::meta::cpp2::ListSnapshotsResp> semifuture_listSnapshots(const ::nebula::meta::cpp2::ListSnapshotsReq& p_req) = 0; + virtual void async_tm_runAdminJob(std::unique_ptr> callback, const ::nebula::meta::cpp2::AdminJobReq& p_req) = 0; + virtual folly::Future< ::nebula::meta::cpp2::AdminJobResp> future_runAdminJob(const ::nebula::meta::cpp2::AdminJobReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::meta::cpp2::AdminJobResp> semifuture_runAdminJob(const ::nebula::meta::cpp2::AdminJobReq& p_req) = 0; + virtual void async_tm_addZone(std::unique_ptr> callback, const ::nebula::meta::cpp2::AddZoneReq& p_req) = 0; + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_addZone(const ::nebula::meta::cpp2::AddZoneReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_addZone(const ::nebula::meta::cpp2::AddZoneReq& p_req) = 0; + virtual void async_tm_dropZone(std::unique_ptr> callback, const ::nebula::meta::cpp2::DropZoneReq& p_req) = 0; + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_dropZone(const ::nebula::meta::cpp2::DropZoneReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_dropZone(const ::nebula::meta::cpp2::DropZoneReq& p_req) = 0; + virtual void async_tm_addHostIntoZone(std::unique_ptr> callback, const ::nebula::meta::cpp2::AddHostIntoZoneReq& p_req) = 0; + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_addHostIntoZone(const ::nebula::meta::cpp2::AddHostIntoZoneReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_addHostIntoZone(const ::nebula::meta::cpp2::AddHostIntoZoneReq& p_req) = 0; + virtual void async_tm_dropHostFromZone(std::unique_ptr> callback, const ::nebula::meta::cpp2::DropHostFromZoneReq& p_req) = 0; + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_dropHostFromZone(const ::nebula::meta::cpp2::DropHostFromZoneReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_dropHostFromZone(const ::nebula::meta::cpp2::DropHostFromZoneReq& p_req) = 0; + virtual void async_tm_getZone(std::unique_ptr> callback, const ::nebula::meta::cpp2::GetZoneReq& p_req) = 0; + virtual folly::Future< ::nebula::meta::cpp2::GetZoneResp> future_getZone(const ::nebula::meta::cpp2::GetZoneReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::meta::cpp2::GetZoneResp> semifuture_getZone(const ::nebula::meta::cpp2::GetZoneReq& p_req) = 0; + virtual void async_tm_listZones(std::unique_ptr> callback, const ::nebula::meta::cpp2::ListZonesReq& p_req) = 0; + virtual folly::Future< ::nebula::meta::cpp2::ListZonesResp> future_listZones(const ::nebula::meta::cpp2::ListZonesReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::meta::cpp2::ListZonesResp> semifuture_listZones(const ::nebula::meta::cpp2::ListZonesReq& p_req) = 0; + virtual void async_tm_addGroup(std::unique_ptr> callback, const ::nebula::meta::cpp2::AddGroupReq& p_req) = 0; + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_addGroup(const ::nebula::meta::cpp2::AddGroupReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_addGroup(const ::nebula::meta::cpp2::AddGroupReq& p_req) = 0; + virtual void async_tm_dropGroup(std::unique_ptr> callback, const ::nebula::meta::cpp2::DropGroupReq& p_req) = 0; + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_dropGroup(const ::nebula::meta::cpp2::DropGroupReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_dropGroup(const ::nebula::meta::cpp2::DropGroupReq& p_req) = 0; + virtual void async_tm_addZoneIntoGroup(std::unique_ptr> callback, const ::nebula::meta::cpp2::AddZoneIntoGroupReq& p_req) = 0; + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_addZoneIntoGroup(const ::nebula::meta::cpp2::AddZoneIntoGroupReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_addZoneIntoGroup(const ::nebula::meta::cpp2::AddZoneIntoGroupReq& p_req) = 0; + virtual void async_tm_dropZoneFromGroup(std::unique_ptr> callback, const ::nebula::meta::cpp2::DropZoneFromGroupReq& p_req) = 0; + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_dropZoneFromGroup(const ::nebula::meta::cpp2::DropZoneFromGroupReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_dropZoneFromGroup(const ::nebula::meta::cpp2::DropZoneFromGroupReq& p_req) = 0; + virtual void async_tm_getGroup(std::unique_ptr> callback, const ::nebula::meta::cpp2::GetGroupReq& p_req) = 0; + virtual folly::Future< ::nebula::meta::cpp2::GetGroupResp> future_getGroup(const ::nebula::meta::cpp2::GetGroupReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::meta::cpp2::GetGroupResp> semifuture_getGroup(const ::nebula::meta::cpp2::GetGroupReq& p_req) = 0; + virtual void async_tm_listGroups(std::unique_ptr> callback, const ::nebula::meta::cpp2::ListGroupsReq& p_req) = 0; + virtual folly::Future< ::nebula::meta::cpp2::ListGroupsResp> future_listGroups(const ::nebula::meta::cpp2::ListGroupsReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::meta::cpp2::ListGroupsResp> semifuture_listGroups(const ::nebula::meta::cpp2::ListGroupsReq& p_req) = 0; + virtual void async_tm_createBackup(std::unique_ptr> callback, const ::nebula::meta::cpp2::CreateBackupReq& p_req) = 0; + virtual folly::Future< ::nebula::meta::cpp2::CreateBackupResp> future_createBackup(const ::nebula::meta::cpp2::CreateBackupReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::meta::cpp2::CreateBackupResp> semifuture_createBackup(const ::nebula::meta::cpp2::CreateBackupReq& p_req) = 0; + virtual void async_tm_restoreMeta(std::unique_ptr> callback, const ::nebula::meta::cpp2::RestoreMetaReq& p_req) = 0; + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_restoreMeta(const ::nebula::meta::cpp2::RestoreMetaReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_restoreMeta(const ::nebula::meta::cpp2::RestoreMetaReq& p_req) = 0; + virtual void async_tm_addListener(std::unique_ptr> callback, const ::nebula::meta::cpp2::AddListenerReq& p_req) = 0; + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_addListener(const ::nebula::meta::cpp2::AddListenerReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_addListener(const ::nebula::meta::cpp2::AddListenerReq& p_req) = 0; + virtual void async_tm_removeListener(std::unique_ptr> callback, const ::nebula::meta::cpp2::RemoveListenerReq& p_req) = 0; + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_removeListener(const ::nebula::meta::cpp2::RemoveListenerReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_removeListener(const ::nebula::meta::cpp2::RemoveListenerReq& p_req) = 0; + virtual void async_tm_listListener(std::unique_ptr> callback, const ::nebula::meta::cpp2::ListListenerReq& p_req) = 0; + virtual folly::Future< ::nebula::meta::cpp2::ListListenerResp> future_listListener(const ::nebula::meta::cpp2::ListListenerReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::meta::cpp2::ListListenerResp> semifuture_listListener(const ::nebula::meta::cpp2::ListListenerReq& p_req) = 0; + virtual void async_tm_getStats(std::unique_ptr> callback, const ::nebula::meta::cpp2::GetStatsReq& p_req) = 0; + virtual folly::Future< ::nebula::meta::cpp2::GetStatsResp> future_getStats(const ::nebula::meta::cpp2::GetStatsReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::meta::cpp2::GetStatsResp> semifuture_getStats(const ::nebula::meta::cpp2::GetStatsReq& p_req) = 0; + virtual void async_tm_signInFTService(std::unique_ptr> callback, const ::nebula::meta::cpp2::SignInFTServiceReq& p_req) = 0; + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_signInFTService(const ::nebula::meta::cpp2::SignInFTServiceReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_signInFTService(const ::nebula::meta::cpp2::SignInFTServiceReq& p_req) = 0; + virtual void async_tm_signOutFTService(std::unique_ptr> callback, const ::nebula::meta::cpp2::SignOutFTServiceReq& p_req) = 0; + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_signOutFTService(const ::nebula::meta::cpp2::SignOutFTServiceReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_signOutFTService(const ::nebula::meta::cpp2::SignOutFTServiceReq& p_req) = 0; + virtual void async_tm_listFTClients(std::unique_ptr> callback, const ::nebula::meta::cpp2::ListFTClientsReq& p_req) = 0; + virtual folly::Future< ::nebula::meta::cpp2::ListFTClientsResp> future_listFTClients(const ::nebula::meta::cpp2::ListFTClientsReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::meta::cpp2::ListFTClientsResp> semifuture_listFTClients(const ::nebula::meta::cpp2::ListFTClientsReq& p_req) = 0; + virtual void async_tm_createFTIndex(std::unique_ptr> callback, const ::nebula::meta::cpp2::CreateFTIndexReq& p_req) = 0; + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_createFTIndex(const ::nebula::meta::cpp2::CreateFTIndexReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_createFTIndex(const ::nebula::meta::cpp2::CreateFTIndexReq& p_req) = 0; + virtual void async_tm_dropFTIndex(std::unique_ptr> callback, const ::nebula::meta::cpp2::DropFTIndexReq& p_req) = 0; + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_dropFTIndex(const ::nebula::meta::cpp2::DropFTIndexReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_dropFTIndex(const ::nebula::meta::cpp2::DropFTIndexReq& p_req) = 0; + virtual void async_tm_listFTIndexes(std::unique_ptr> callback, const ::nebula::meta::cpp2::ListFTIndexesReq& p_req) = 0; + virtual folly::Future< ::nebula::meta::cpp2::ListFTIndexesResp> future_listFTIndexes(const ::nebula::meta::cpp2::ListFTIndexesReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::meta::cpp2::ListFTIndexesResp> semifuture_listFTIndexes(const ::nebula::meta::cpp2::ListFTIndexesReq& p_req) = 0; + virtual void async_tm_createSession(std::unique_ptr> callback, const ::nebula::meta::cpp2::CreateSessionReq& p_req) = 0; + virtual folly::Future< ::nebula::meta::cpp2::CreateSessionResp> future_createSession(const ::nebula::meta::cpp2::CreateSessionReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::meta::cpp2::CreateSessionResp> semifuture_createSession(const ::nebula::meta::cpp2::CreateSessionReq& p_req) = 0; + virtual void async_tm_updateSessions(std::unique_ptr> callback, const ::nebula::meta::cpp2::UpdateSessionsReq& p_req) = 0; + virtual folly::Future< ::nebula::meta::cpp2::UpdateSessionsResp> future_updateSessions(const ::nebula::meta::cpp2::UpdateSessionsReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::meta::cpp2::UpdateSessionsResp> semifuture_updateSessions(const ::nebula::meta::cpp2::UpdateSessionsReq& p_req) = 0; + virtual void async_tm_listSessions(std::unique_ptr> callback, const ::nebula::meta::cpp2::ListSessionsReq& p_req) = 0; + virtual folly::Future< ::nebula::meta::cpp2::ListSessionsResp> future_listSessions(const ::nebula::meta::cpp2::ListSessionsReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::meta::cpp2::ListSessionsResp> semifuture_listSessions(const ::nebula::meta::cpp2::ListSessionsReq& p_req) = 0; + virtual void async_tm_getSession(std::unique_ptr> callback, const ::nebula::meta::cpp2::GetSessionReq& p_req) = 0; + virtual folly::Future< ::nebula::meta::cpp2::GetSessionResp> future_getSession(const ::nebula::meta::cpp2::GetSessionReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::meta::cpp2::GetSessionResp> semifuture_getSession(const ::nebula::meta::cpp2::GetSessionReq& p_req) = 0; + virtual void async_tm_removeSession(std::unique_ptr> callback, const ::nebula::meta::cpp2::RemoveSessionReq& p_req) = 0; + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_removeSession(const ::nebula::meta::cpp2::RemoveSessionReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_removeSession(const ::nebula::meta::cpp2::RemoveSessionReq& p_req) = 0; + virtual void async_tm_killQuery(std::unique_ptr> callback, const ::nebula::meta::cpp2::KillQueryReq& p_req) = 0; + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_killQuery(const ::nebula::meta::cpp2::KillQueryReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_killQuery(const ::nebula::meta::cpp2::KillQueryReq& p_req) = 0; + virtual void async_tm_reportTaskFinish(std::unique_ptr> callback, const ::nebula::meta::cpp2::ReportTaskReq& p_req) = 0; + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_reportTaskFinish(const ::nebula::meta::cpp2::ReportTaskReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_reportTaskFinish(const ::nebula::meta::cpp2::ReportTaskReq& p_req) = 0; + virtual void async_tm_listCluster(std::unique_ptr> callback, const ::nebula::meta::cpp2::ListClusterInfoReq& p_req) = 0; + virtual folly::Future< ::nebula::meta::cpp2::ListClusterInfoResp> future_listCluster(const ::nebula::meta::cpp2::ListClusterInfoReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::meta::cpp2::ListClusterInfoResp> semifuture_listCluster(const ::nebula::meta::cpp2::ListClusterInfoReq& p_req) = 0; + virtual void async_tm_getMetaDirInfo(std::unique_ptr> callback, const ::nebula::meta::cpp2::GetMetaDirInfoReq& p_req) = 0; + virtual folly::Future< ::nebula::meta::cpp2::GetMetaDirInfoResp> future_getMetaDirInfo(const ::nebula::meta::cpp2::GetMetaDirInfoReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::meta::cpp2::GetMetaDirInfoResp> semifuture_getMetaDirInfo(const ::nebula::meta::cpp2::GetMetaDirInfoReq& p_req) = 0; + virtual void async_tm_verifyClientVersion(std::unique_ptr> callback, const ::nebula::meta::cpp2::VerifyClientVersionReq& p_req) = 0; + virtual folly::Future< ::nebula::meta::cpp2::VerifyClientVersionResp> future_verifyClientVersion(const ::nebula::meta::cpp2::VerifyClientVersionReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::meta::cpp2::VerifyClientVersionResp> semifuture_verifyClientVersion(const ::nebula::meta::cpp2::VerifyClientVersionReq& p_req) = 0; +}; + +class MetaServiceAsyncProcessor; + +class MetaServiceSvIf : public MetaServiceSvAsyncIf, public apache::thrift::ServerInterface { + public: + typedef MetaServiceAsyncProcessor ProcessorType; + std::unique_ptr getProcessor() override; + + + virtual void createSpace( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::CreateSpaceReq& /*req*/); + folly::Future< ::nebula::meta::cpp2::ExecResp> future_createSpace(const ::nebula::meta::cpp2::CreateSpaceReq& p_req) override; + folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_createSpace(const ::nebula::meta::cpp2::CreateSpaceReq& p_req) override; + void async_tm_createSpace(std::unique_ptr> callback, const ::nebula::meta::cpp2::CreateSpaceReq& p_req) override; + virtual void dropSpace( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::DropSpaceReq& /*req*/); + folly::Future< ::nebula::meta::cpp2::ExecResp> future_dropSpace(const ::nebula::meta::cpp2::DropSpaceReq& p_req) override; + folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_dropSpace(const ::nebula::meta::cpp2::DropSpaceReq& p_req) override; + void async_tm_dropSpace(std::unique_ptr> callback, const ::nebula::meta::cpp2::DropSpaceReq& p_req) override; + virtual void getSpace( ::nebula::meta::cpp2::GetSpaceResp& /*_return*/, const ::nebula::meta::cpp2::GetSpaceReq& /*req*/); + folly::Future< ::nebula::meta::cpp2::GetSpaceResp> future_getSpace(const ::nebula::meta::cpp2::GetSpaceReq& p_req) override; + folly::SemiFuture< ::nebula::meta::cpp2::GetSpaceResp> semifuture_getSpace(const ::nebula::meta::cpp2::GetSpaceReq& p_req) override; + void async_tm_getSpace(std::unique_ptr> callback, const ::nebula::meta::cpp2::GetSpaceReq& p_req) override; + virtual void listSpaces( ::nebula::meta::cpp2::ListSpacesResp& /*_return*/, const ::nebula::meta::cpp2::ListSpacesReq& /*req*/); + folly::Future< ::nebula::meta::cpp2::ListSpacesResp> future_listSpaces(const ::nebula::meta::cpp2::ListSpacesReq& p_req) override; + folly::SemiFuture< ::nebula::meta::cpp2::ListSpacesResp> semifuture_listSpaces(const ::nebula::meta::cpp2::ListSpacesReq& p_req) override; + void async_tm_listSpaces(std::unique_ptr> callback, const ::nebula::meta::cpp2::ListSpacesReq& p_req) override; + virtual void createSpaceAs( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::CreateSpaceAsReq& /*req*/); + folly::Future< ::nebula::meta::cpp2::ExecResp> future_createSpaceAs(const ::nebula::meta::cpp2::CreateSpaceAsReq& p_req) override; + folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_createSpaceAs(const ::nebula::meta::cpp2::CreateSpaceAsReq& p_req) override; + void async_tm_createSpaceAs(std::unique_ptr> callback, const ::nebula::meta::cpp2::CreateSpaceAsReq& p_req) override; + virtual void createTag( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::CreateTagReq& /*req*/); + folly::Future< ::nebula::meta::cpp2::ExecResp> future_createTag(const ::nebula::meta::cpp2::CreateTagReq& p_req) override; + folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_createTag(const ::nebula::meta::cpp2::CreateTagReq& p_req) override; + void async_tm_createTag(std::unique_ptr> callback, const ::nebula::meta::cpp2::CreateTagReq& p_req) override; + virtual void alterTag( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::AlterTagReq& /*req*/); + folly::Future< ::nebula::meta::cpp2::ExecResp> future_alterTag(const ::nebula::meta::cpp2::AlterTagReq& p_req) override; + folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_alterTag(const ::nebula::meta::cpp2::AlterTagReq& p_req) override; + void async_tm_alterTag(std::unique_ptr> callback, const ::nebula::meta::cpp2::AlterTagReq& p_req) override; + virtual void dropTag( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::DropTagReq& /*req*/); + folly::Future< ::nebula::meta::cpp2::ExecResp> future_dropTag(const ::nebula::meta::cpp2::DropTagReq& p_req) override; + folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_dropTag(const ::nebula::meta::cpp2::DropTagReq& p_req) override; + void async_tm_dropTag(std::unique_ptr> callback, const ::nebula::meta::cpp2::DropTagReq& p_req) override; + virtual void getTag( ::nebula::meta::cpp2::GetTagResp& /*_return*/, const ::nebula::meta::cpp2::GetTagReq& /*req*/); + folly::Future< ::nebula::meta::cpp2::GetTagResp> future_getTag(const ::nebula::meta::cpp2::GetTagReq& p_req) override; + folly::SemiFuture< ::nebula::meta::cpp2::GetTagResp> semifuture_getTag(const ::nebula::meta::cpp2::GetTagReq& p_req) override; + void async_tm_getTag(std::unique_ptr> callback, const ::nebula::meta::cpp2::GetTagReq& p_req) override; + virtual void listTags( ::nebula::meta::cpp2::ListTagsResp& /*_return*/, const ::nebula::meta::cpp2::ListTagsReq& /*req*/); + folly::Future< ::nebula::meta::cpp2::ListTagsResp> future_listTags(const ::nebula::meta::cpp2::ListTagsReq& p_req) override; + folly::SemiFuture< ::nebula::meta::cpp2::ListTagsResp> semifuture_listTags(const ::nebula::meta::cpp2::ListTagsReq& p_req) override; + void async_tm_listTags(std::unique_ptr> callback, const ::nebula::meta::cpp2::ListTagsReq& p_req) override; + virtual void createEdge( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::CreateEdgeReq& /*req*/); + folly::Future< ::nebula::meta::cpp2::ExecResp> future_createEdge(const ::nebula::meta::cpp2::CreateEdgeReq& p_req) override; + folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_createEdge(const ::nebula::meta::cpp2::CreateEdgeReq& p_req) override; + void async_tm_createEdge(std::unique_ptr> callback, const ::nebula::meta::cpp2::CreateEdgeReq& p_req) override; + virtual void alterEdge( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::AlterEdgeReq& /*req*/); + folly::Future< ::nebula::meta::cpp2::ExecResp> future_alterEdge(const ::nebula::meta::cpp2::AlterEdgeReq& p_req) override; + folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_alterEdge(const ::nebula::meta::cpp2::AlterEdgeReq& p_req) override; + void async_tm_alterEdge(std::unique_ptr> callback, const ::nebula::meta::cpp2::AlterEdgeReq& p_req) override; + virtual void dropEdge( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::DropEdgeReq& /*req*/); + folly::Future< ::nebula::meta::cpp2::ExecResp> future_dropEdge(const ::nebula::meta::cpp2::DropEdgeReq& p_req) override; + folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_dropEdge(const ::nebula::meta::cpp2::DropEdgeReq& p_req) override; + void async_tm_dropEdge(std::unique_ptr> callback, const ::nebula::meta::cpp2::DropEdgeReq& p_req) override; + virtual void getEdge( ::nebula::meta::cpp2::GetEdgeResp& /*_return*/, const ::nebula::meta::cpp2::GetEdgeReq& /*req*/); + folly::Future< ::nebula::meta::cpp2::GetEdgeResp> future_getEdge(const ::nebula::meta::cpp2::GetEdgeReq& p_req) override; + folly::SemiFuture< ::nebula::meta::cpp2::GetEdgeResp> semifuture_getEdge(const ::nebula::meta::cpp2::GetEdgeReq& p_req) override; + void async_tm_getEdge(std::unique_ptr> callback, const ::nebula::meta::cpp2::GetEdgeReq& p_req) override; + virtual void listEdges( ::nebula::meta::cpp2::ListEdgesResp& /*_return*/, const ::nebula::meta::cpp2::ListEdgesReq& /*req*/); + folly::Future< ::nebula::meta::cpp2::ListEdgesResp> future_listEdges(const ::nebula::meta::cpp2::ListEdgesReq& p_req) override; + folly::SemiFuture< ::nebula::meta::cpp2::ListEdgesResp> semifuture_listEdges(const ::nebula::meta::cpp2::ListEdgesReq& p_req) override; + void async_tm_listEdges(std::unique_ptr> callback, const ::nebula::meta::cpp2::ListEdgesReq& p_req) override; + virtual void listHosts( ::nebula::meta::cpp2::ListHostsResp& /*_return*/, const ::nebula::meta::cpp2::ListHostsReq& /*req*/); + folly::Future< ::nebula::meta::cpp2::ListHostsResp> future_listHosts(const ::nebula::meta::cpp2::ListHostsReq& p_req) override; + folly::SemiFuture< ::nebula::meta::cpp2::ListHostsResp> semifuture_listHosts(const ::nebula::meta::cpp2::ListHostsReq& p_req) override; + void async_tm_listHosts(std::unique_ptr> callback, const ::nebula::meta::cpp2::ListHostsReq& p_req) override; + virtual void getPartsAlloc( ::nebula::meta::cpp2::GetPartsAllocResp& /*_return*/, const ::nebula::meta::cpp2::GetPartsAllocReq& /*req*/); + folly::Future< ::nebula::meta::cpp2::GetPartsAllocResp> future_getPartsAlloc(const ::nebula::meta::cpp2::GetPartsAllocReq& p_req) override; + folly::SemiFuture< ::nebula::meta::cpp2::GetPartsAllocResp> semifuture_getPartsAlloc(const ::nebula::meta::cpp2::GetPartsAllocReq& p_req) override; + void async_tm_getPartsAlloc(std::unique_ptr> callback, const ::nebula::meta::cpp2::GetPartsAllocReq& p_req) override; + virtual void listParts( ::nebula::meta::cpp2::ListPartsResp& /*_return*/, const ::nebula::meta::cpp2::ListPartsReq& /*req*/); + folly::Future< ::nebula::meta::cpp2::ListPartsResp> future_listParts(const ::nebula::meta::cpp2::ListPartsReq& p_req) override; + folly::SemiFuture< ::nebula::meta::cpp2::ListPartsResp> semifuture_listParts(const ::nebula::meta::cpp2::ListPartsReq& p_req) override; + void async_tm_listParts(std::unique_ptr> callback, const ::nebula::meta::cpp2::ListPartsReq& p_req) override; + virtual void multiPut( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::MultiPutReq& /*req*/); + folly::Future< ::nebula::meta::cpp2::ExecResp> future_multiPut(const ::nebula::meta::cpp2::MultiPutReq& p_req) override; + folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_multiPut(const ::nebula::meta::cpp2::MultiPutReq& p_req) override; + void async_tm_multiPut(std::unique_ptr> callback, const ::nebula::meta::cpp2::MultiPutReq& p_req) override; + virtual void get( ::nebula::meta::cpp2::GetResp& /*_return*/, const ::nebula::meta::cpp2::GetReq& /*req*/); + folly::Future< ::nebula::meta::cpp2::GetResp> future_get(const ::nebula::meta::cpp2::GetReq& p_req) override; + folly::SemiFuture< ::nebula::meta::cpp2::GetResp> semifuture_get(const ::nebula::meta::cpp2::GetReq& p_req) override; + void async_tm_get(std::unique_ptr> callback, const ::nebula::meta::cpp2::GetReq& p_req) override; + virtual void multiGet( ::nebula::meta::cpp2::MultiGetResp& /*_return*/, const ::nebula::meta::cpp2::MultiGetReq& /*req*/); + folly::Future< ::nebula::meta::cpp2::MultiGetResp> future_multiGet(const ::nebula::meta::cpp2::MultiGetReq& p_req) override; + folly::SemiFuture< ::nebula::meta::cpp2::MultiGetResp> semifuture_multiGet(const ::nebula::meta::cpp2::MultiGetReq& p_req) override; + void async_tm_multiGet(std::unique_ptr> callback, const ::nebula::meta::cpp2::MultiGetReq& p_req) override; + virtual void remove( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::RemoveReq& /*req*/); + folly::Future< ::nebula::meta::cpp2::ExecResp> future_remove(const ::nebula::meta::cpp2::RemoveReq& p_req) override; + folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_remove(const ::nebula::meta::cpp2::RemoveReq& p_req) override; + void async_tm_remove(std::unique_ptr> callback, const ::nebula::meta::cpp2::RemoveReq& p_req) override; + virtual void removeRange( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::RemoveRangeReq& /*req*/); + folly::Future< ::nebula::meta::cpp2::ExecResp> future_removeRange(const ::nebula::meta::cpp2::RemoveRangeReq& p_req) override; + folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_removeRange(const ::nebula::meta::cpp2::RemoveRangeReq& p_req) override; + void async_tm_removeRange(std::unique_ptr> callback, const ::nebula::meta::cpp2::RemoveRangeReq& p_req) override; + virtual void scan( ::nebula::meta::cpp2::ScanResp& /*_return*/, const ::nebula::meta::cpp2::ScanReq& /*req*/); + folly::Future< ::nebula::meta::cpp2::ScanResp> future_scan(const ::nebula::meta::cpp2::ScanReq& p_req) override; + folly::SemiFuture< ::nebula::meta::cpp2::ScanResp> semifuture_scan(const ::nebula::meta::cpp2::ScanReq& p_req) override; + void async_tm_scan(std::unique_ptr> callback, const ::nebula::meta::cpp2::ScanReq& p_req) override; + virtual void createTagIndex( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::CreateTagIndexReq& /*req*/); + folly::Future< ::nebula::meta::cpp2::ExecResp> future_createTagIndex(const ::nebula::meta::cpp2::CreateTagIndexReq& p_req) override; + folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_createTagIndex(const ::nebula::meta::cpp2::CreateTagIndexReq& p_req) override; + void async_tm_createTagIndex(std::unique_ptr> callback, const ::nebula::meta::cpp2::CreateTagIndexReq& p_req) override; + virtual void dropTagIndex( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::DropTagIndexReq& /*req*/); + folly::Future< ::nebula::meta::cpp2::ExecResp> future_dropTagIndex(const ::nebula::meta::cpp2::DropTagIndexReq& p_req) override; + folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_dropTagIndex(const ::nebula::meta::cpp2::DropTagIndexReq& p_req) override; + void async_tm_dropTagIndex(std::unique_ptr> callback, const ::nebula::meta::cpp2::DropTagIndexReq& p_req) override; + virtual void getTagIndex( ::nebula::meta::cpp2::GetTagIndexResp& /*_return*/, const ::nebula::meta::cpp2::GetTagIndexReq& /*req*/); + folly::Future< ::nebula::meta::cpp2::GetTagIndexResp> future_getTagIndex(const ::nebula::meta::cpp2::GetTagIndexReq& p_req) override; + folly::SemiFuture< ::nebula::meta::cpp2::GetTagIndexResp> semifuture_getTagIndex(const ::nebula::meta::cpp2::GetTagIndexReq& p_req) override; + void async_tm_getTagIndex(std::unique_ptr> callback, const ::nebula::meta::cpp2::GetTagIndexReq& p_req) override; + virtual void listTagIndexes( ::nebula::meta::cpp2::ListTagIndexesResp& /*_return*/, const ::nebula::meta::cpp2::ListTagIndexesReq& /*req*/); + folly::Future< ::nebula::meta::cpp2::ListTagIndexesResp> future_listTagIndexes(const ::nebula::meta::cpp2::ListTagIndexesReq& p_req) override; + folly::SemiFuture< ::nebula::meta::cpp2::ListTagIndexesResp> semifuture_listTagIndexes(const ::nebula::meta::cpp2::ListTagIndexesReq& p_req) override; + void async_tm_listTagIndexes(std::unique_ptr> callback, const ::nebula::meta::cpp2::ListTagIndexesReq& p_req) override; + virtual void rebuildTagIndex( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::RebuildIndexReq& /*req*/); + folly::Future< ::nebula::meta::cpp2::ExecResp> future_rebuildTagIndex(const ::nebula::meta::cpp2::RebuildIndexReq& p_req) override; + folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_rebuildTagIndex(const ::nebula::meta::cpp2::RebuildIndexReq& p_req) override; + void async_tm_rebuildTagIndex(std::unique_ptr> callback, const ::nebula::meta::cpp2::RebuildIndexReq& p_req) override; + virtual void listTagIndexStatus( ::nebula::meta::cpp2::ListIndexStatusResp& /*_return*/, const ::nebula::meta::cpp2::ListIndexStatusReq& /*req*/); + folly::Future< ::nebula::meta::cpp2::ListIndexStatusResp> future_listTagIndexStatus(const ::nebula::meta::cpp2::ListIndexStatusReq& p_req) override; + folly::SemiFuture< ::nebula::meta::cpp2::ListIndexStatusResp> semifuture_listTagIndexStatus(const ::nebula::meta::cpp2::ListIndexStatusReq& p_req) override; + void async_tm_listTagIndexStatus(std::unique_ptr> callback, const ::nebula::meta::cpp2::ListIndexStatusReq& p_req) override; + virtual void createEdgeIndex( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::CreateEdgeIndexReq& /*req*/); + folly::Future< ::nebula::meta::cpp2::ExecResp> future_createEdgeIndex(const ::nebula::meta::cpp2::CreateEdgeIndexReq& p_req) override; + folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_createEdgeIndex(const ::nebula::meta::cpp2::CreateEdgeIndexReq& p_req) override; + void async_tm_createEdgeIndex(std::unique_ptr> callback, const ::nebula::meta::cpp2::CreateEdgeIndexReq& p_req) override; + virtual void dropEdgeIndex( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::DropEdgeIndexReq& /*req*/); + folly::Future< ::nebula::meta::cpp2::ExecResp> future_dropEdgeIndex(const ::nebula::meta::cpp2::DropEdgeIndexReq& p_req) override; + folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_dropEdgeIndex(const ::nebula::meta::cpp2::DropEdgeIndexReq& p_req) override; + void async_tm_dropEdgeIndex(std::unique_ptr> callback, const ::nebula::meta::cpp2::DropEdgeIndexReq& p_req) override; + virtual void getEdgeIndex( ::nebula::meta::cpp2::GetEdgeIndexResp& /*_return*/, const ::nebula::meta::cpp2::GetEdgeIndexReq& /*req*/); + folly::Future< ::nebula::meta::cpp2::GetEdgeIndexResp> future_getEdgeIndex(const ::nebula::meta::cpp2::GetEdgeIndexReq& p_req) override; + folly::SemiFuture< ::nebula::meta::cpp2::GetEdgeIndexResp> semifuture_getEdgeIndex(const ::nebula::meta::cpp2::GetEdgeIndexReq& p_req) override; + void async_tm_getEdgeIndex(std::unique_ptr> callback, const ::nebula::meta::cpp2::GetEdgeIndexReq& p_req) override; + virtual void listEdgeIndexes( ::nebula::meta::cpp2::ListEdgeIndexesResp& /*_return*/, const ::nebula::meta::cpp2::ListEdgeIndexesReq& /*req*/); + folly::Future< ::nebula::meta::cpp2::ListEdgeIndexesResp> future_listEdgeIndexes(const ::nebula::meta::cpp2::ListEdgeIndexesReq& p_req) override; + folly::SemiFuture< ::nebula::meta::cpp2::ListEdgeIndexesResp> semifuture_listEdgeIndexes(const ::nebula::meta::cpp2::ListEdgeIndexesReq& p_req) override; + void async_tm_listEdgeIndexes(std::unique_ptr> callback, const ::nebula::meta::cpp2::ListEdgeIndexesReq& p_req) override; + virtual void rebuildEdgeIndex( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::RebuildIndexReq& /*req*/); + folly::Future< ::nebula::meta::cpp2::ExecResp> future_rebuildEdgeIndex(const ::nebula::meta::cpp2::RebuildIndexReq& p_req) override; + folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_rebuildEdgeIndex(const ::nebula::meta::cpp2::RebuildIndexReq& p_req) override; + void async_tm_rebuildEdgeIndex(std::unique_ptr> callback, const ::nebula::meta::cpp2::RebuildIndexReq& p_req) override; + virtual void listEdgeIndexStatus( ::nebula::meta::cpp2::ListIndexStatusResp& /*_return*/, const ::nebula::meta::cpp2::ListIndexStatusReq& /*req*/); + folly::Future< ::nebula::meta::cpp2::ListIndexStatusResp> future_listEdgeIndexStatus(const ::nebula::meta::cpp2::ListIndexStatusReq& p_req) override; + folly::SemiFuture< ::nebula::meta::cpp2::ListIndexStatusResp> semifuture_listEdgeIndexStatus(const ::nebula::meta::cpp2::ListIndexStatusReq& p_req) override; + void async_tm_listEdgeIndexStatus(std::unique_ptr> callback, const ::nebula::meta::cpp2::ListIndexStatusReq& p_req) override; + virtual void createUser( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::CreateUserReq& /*req*/); + folly::Future< ::nebula::meta::cpp2::ExecResp> future_createUser(const ::nebula::meta::cpp2::CreateUserReq& p_req) override; + folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_createUser(const ::nebula::meta::cpp2::CreateUserReq& p_req) override; + void async_tm_createUser(std::unique_ptr> callback, const ::nebula::meta::cpp2::CreateUserReq& p_req) override; + virtual void dropUser( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::DropUserReq& /*req*/); + folly::Future< ::nebula::meta::cpp2::ExecResp> future_dropUser(const ::nebula::meta::cpp2::DropUserReq& p_req) override; + folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_dropUser(const ::nebula::meta::cpp2::DropUserReq& p_req) override; + void async_tm_dropUser(std::unique_ptr> callback, const ::nebula::meta::cpp2::DropUserReq& p_req) override; + virtual void alterUser( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::AlterUserReq& /*req*/); + folly::Future< ::nebula::meta::cpp2::ExecResp> future_alterUser(const ::nebula::meta::cpp2::AlterUserReq& p_req) override; + folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_alterUser(const ::nebula::meta::cpp2::AlterUserReq& p_req) override; + void async_tm_alterUser(std::unique_ptr> callback, const ::nebula::meta::cpp2::AlterUserReq& p_req) override; + virtual void grantRole( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::GrantRoleReq& /*req*/); + folly::Future< ::nebula::meta::cpp2::ExecResp> future_grantRole(const ::nebula::meta::cpp2::GrantRoleReq& p_req) override; + folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_grantRole(const ::nebula::meta::cpp2::GrantRoleReq& p_req) override; + void async_tm_grantRole(std::unique_ptr> callback, const ::nebula::meta::cpp2::GrantRoleReq& p_req) override; + virtual void revokeRole( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::RevokeRoleReq& /*req*/); + folly::Future< ::nebula::meta::cpp2::ExecResp> future_revokeRole(const ::nebula::meta::cpp2::RevokeRoleReq& p_req) override; + folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_revokeRole(const ::nebula::meta::cpp2::RevokeRoleReq& p_req) override; + void async_tm_revokeRole(std::unique_ptr> callback, const ::nebula::meta::cpp2::RevokeRoleReq& p_req) override; + virtual void listUsers( ::nebula::meta::cpp2::ListUsersResp& /*_return*/, const ::nebula::meta::cpp2::ListUsersReq& /*req*/); + folly::Future< ::nebula::meta::cpp2::ListUsersResp> future_listUsers(const ::nebula::meta::cpp2::ListUsersReq& p_req) override; + folly::SemiFuture< ::nebula::meta::cpp2::ListUsersResp> semifuture_listUsers(const ::nebula::meta::cpp2::ListUsersReq& p_req) override; + void async_tm_listUsers(std::unique_ptr> callback, const ::nebula::meta::cpp2::ListUsersReq& p_req) override; + virtual void listRoles( ::nebula::meta::cpp2::ListRolesResp& /*_return*/, const ::nebula::meta::cpp2::ListRolesReq& /*req*/); + folly::Future< ::nebula::meta::cpp2::ListRolesResp> future_listRoles(const ::nebula::meta::cpp2::ListRolesReq& p_req) override; + folly::SemiFuture< ::nebula::meta::cpp2::ListRolesResp> semifuture_listRoles(const ::nebula::meta::cpp2::ListRolesReq& p_req) override; + void async_tm_listRoles(std::unique_ptr> callback, const ::nebula::meta::cpp2::ListRolesReq& p_req) override; + virtual void getUserRoles( ::nebula::meta::cpp2::ListRolesResp& /*_return*/, const ::nebula::meta::cpp2::GetUserRolesReq& /*req*/); + folly::Future< ::nebula::meta::cpp2::ListRolesResp> future_getUserRoles(const ::nebula::meta::cpp2::GetUserRolesReq& p_req) override; + folly::SemiFuture< ::nebula::meta::cpp2::ListRolesResp> semifuture_getUserRoles(const ::nebula::meta::cpp2::GetUserRolesReq& p_req) override; + void async_tm_getUserRoles(std::unique_ptr> callback, const ::nebula::meta::cpp2::GetUserRolesReq& p_req) override; + virtual void changePassword( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::ChangePasswordReq& /*req*/); + folly::Future< ::nebula::meta::cpp2::ExecResp> future_changePassword(const ::nebula::meta::cpp2::ChangePasswordReq& p_req) override; + folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_changePassword(const ::nebula::meta::cpp2::ChangePasswordReq& p_req) override; + void async_tm_changePassword(std::unique_ptr> callback, const ::nebula::meta::cpp2::ChangePasswordReq& p_req) override; + virtual void heartBeat( ::nebula::meta::cpp2::HBResp& /*_return*/, const ::nebula::meta::cpp2::HBReq& /*req*/); + folly::Future< ::nebula::meta::cpp2::HBResp> future_heartBeat(const ::nebula::meta::cpp2::HBReq& p_req) override; + folly::SemiFuture< ::nebula::meta::cpp2::HBResp> semifuture_heartBeat(const ::nebula::meta::cpp2::HBReq& p_req) override; + void async_tm_heartBeat(std::unique_ptr> callback, const ::nebula::meta::cpp2::HBReq& p_req) override; + virtual void balance( ::nebula::meta::cpp2::BalanceResp& /*_return*/, const ::nebula::meta::cpp2::BalanceReq& /*req*/); + folly::Future< ::nebula::meta::cpp2::BalanceResp> future_balance(const ::nebula::meta::cpp2::BalanceReq& p_req) override; + folly::SemiFuture< ::nebula::meta::cpp2::BalanceResp> semifuture_balance(const ::nebula::meta::cpp2::BalanceReq& p_req) override; + void async_tm_balance(std::unique_ptr> callback, const ::nebula::meta::cpp2::BalanceReq& p_req) override; + virtual void leaderBalance( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::LeaderBalanceReq& /*req*/); + folly::Future< ::nebula::meta::cpp2::ExecResp> future_leaderBalance(const ::nebula::meta::cpp2::LeaderBalanceReq& p_req) override; + folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_leaderBalance(const ::nebula::meta::cpp2::LeaderBalanceReq& p_req) override; + void async_tm_leaderBalance(std::unique_ptr> callback, const ::nebula::meta::cpp2::LeaderBalanceReq& p_req) override; + virtual void regConfig( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::RegConfigReq& /*req*/); + folly::Future< ::nebula::meta::cpp2::ExecResp> future_regConfig(const ::nebula::meta::cpp2::RegConfigReq& p_req) override; + folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_regConfig(const ::nebula::meta::cpp2::RegConfigReq& p_req) override; + void async_tm_regConfig(std::unique_ptr> callback, const ::nebula::meta::cpp2::RegConfigReq& p_req) override; + virtual void getConfig( ::nebula::meta::cpp2::GetConfigResp& /*_return*/, const ::nebula::meta::cpp2::GetConfigReq& /*req*/); + folly::Future< ::nebula::meta::cpp2::GetConfigResp> future_getConfig(const ::nebula::meta::cpp2::GetConfigReq& p_req) override; + folly::SemiFuture< ::nebula::meta::cpp2::GetConfigResp> semifuture_getConfig(const ::nebula::meta::cpp2::GetConfigReq& p_req) override; + void async_tm_getConfig(std::unique_ptr> callback, const ::nebula::meta::cpp2::GetConfigReq& p_req) override; + virtual void setConfig( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::SetConfigReq& /*req*/); + folly::Future< ::nebula::meta::cpp2::ExecResp> future_setConfig(const ::nebula::meta::cpp2::SetConfigReq& p_req) override; + folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_setConfig(const ::nebula::meta::cpp2::SetConfigReq& p_req) override; + void async_tm_setConfig(std::unique_ptr> callback, const ::nebula::meta::cpp2::SetConfigReq& p_req) override; + virtual void listConfigs( ::nebula::meta::cpp2::ListConfigsResp& /*_return*/, const ::nebula::meta::cpp2::ListConfigsReq& /*req*/); + folly::Future< ::nebula::meta::cpp2::ListConfigsResp> future_listConfigs(const ::nebula::meta::cpp2::ListConfigsReq& p_req) override; + folly::SemiFuture< ::nebula::meta::cpp2::ListConfigsResp> semifuture_listConfigs(const ::nebula::meta::cpp2::ListConfigsReq& p_req) override; + void async_tm_listConfigs(std::unique_ptr> callback, const ::nebula::meta::cpp2::ListConfigsReq& p_req) override; + virtual void createSnapshot( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::CreateSnapshotReq& /*req*/); + folly::Future< ::nebula::meta::cpp2::ExecResp> future_createSnapshot(const ::nebula::meta::cpp2::CreateSnapshotReq& p_req) override; + folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_createSnapshot(const ::nebula::meta::cpp2::CreateSnapshotReq& p_req) override; + void async_tm_createSnapshot(std::unique_ptr> callback, const ::nebula::meta::cpp2::CreateSnapshotReq& p_req) override; + virtual void dropSnapshot( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::DropSnapshotReq& /*req*/); + folly::Future< ::nebula::meta::cpp2::ExecResp> future_dropSnapshot(const ::nebula::meta::cpp2::DropSnapshotReq& p_req) override; + folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_dropSnapshot(const ::nebula::meta::cpp2::DropSnapshotReq& p_req) override; + void async_tm_dropSnapshot(std::unique_ptr> callback, const ::nebula::meta::cpp2::DropSnapshotReq& p_req) override; + virtual void listSnapshots( ::nebula::meta::cpp2::ListSnapshotsResp& /*_return*/, const ::nebula::meta::cpp2::ListSnapshotsReq& /*req*/); + folly::Future< ::nebula::meta::cpp2::ListSnapshotsResp> future_listSnapshots(const ::nebula::meta::cpp2::ListSnapshotsReq& p_req) override; + folly::SemiFuture< ::nebula::meta::cpp2::ListSnapshotsResp> semifuture_listSnapshots(const ::nebula::meta::cpp2::ListSnapshotsReq& p_req) override; + void async_tm_listSnapshots(std::unique_ptr> callback, const ::nebula::meta::cpp2::ListSnapshotsReq& p_req) override; + virtual void runAdminJob( ::nebula::meta::cpp2::AdminJobResp& /*_return*/, const ::nebula::meta::cpp2::AdminJobReq& /*req*/); + folly::Future< ::nebula::meta::cpp2::AdminJobResp> future_runAdminJob(const ::nebula::meta::cpp2::AdminJobReq& p_req) override; + folly::SemiFuture< ::nebula::meta::cpp2::AdminJobResp> semifuture_runAdminJob(const ::nebula::meta::cpp2::AdminJobReq& p_req) override; + void async_tm_runAdminJob(std::unique_ptr> callback, const ::nebula::meta::cpp2::AdminJobReq& p_req) override; + virtual void addZone( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::AddZoneReq& /*req*/); + folly::Future< ::nebula::meta::cpp2::ExecResp> future_addZone(const ::nebula::meta::cpp2::AddZoneReq& p_req) override; + folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_addZone(const ::nebula::meta::cpp2::AddZoneReq& p_req) override; + void async_tm_addZone(std::unique_ptr> callback, const ::nebula::meta::cpp2::AddZoneReq& p_req) override; + virtual void dropZone( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::DropZoneReq& /*req*/); + folly::Future< ::nebula::meta::cpp2::ExecResp> future_dropZone(const ::nebula::meta::cpp2::DropZoneReq& p_req) override; + folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_dropZone(const ::nebula::meta::cpp2::DropZoneReq& p_req) override; + void async_tm_dropZone(std::unique_ptr> callback, const ::nebula::meta::cpp2::DropZoneReq& p_req) override; + virtual void addHostIntoZone( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::AddHostIntoZoneReq& /*req*/); + folly::Future< ::nebula::meta::cpp2::ExecResp> future_addHostIntoZone(const ::nebula::meta::cpp2::AddHostIntoZoneReq& p_req) override; + folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_addHostIntoZone(const ::nebula::meta::cpp2::AddHostIntoZoneReq& p_req) override; + void async_tm_addHostIntoZone(std::unique_ptr> callback, const ::nebula::meta::cpp2::AddHostIntoZoneReq& p_req) override; + virtual void dropHostFromZone( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::DropHostFromZoneReq& /*req*/); + folly::Future< ::nebula::meta::cpp2::ExecResp> future_dropHostFromZone(const ::nebula::meta::cpp2::DropHostFromZoneReq& p_req) override; + folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_dropHostFromZone(const ::nebula::meta::cpp2::DropHostFromZoneReq& p_req) override; + void async_tm_dropHostFromZone(std::unique_ptr> callback, const ::nebula::meta::cpp2::DropHostFromZoneReq& p_req) override; + virtual void getZone( ::nebula::meta::cpp2::GetZoneResp& /*_return*/, const ::nebula::meta::cpp2::GetZoneReq& /*req*/); + folly::Future< ::nebula::meta::cpp2::GetZoneResp> future_getZone(const ::nebula::meta::cpp2::GetZoneReq& p_req) override; + folly::SemiFuture< ::nebula::meta::cpp2::GetZoneResp> semifuture_getZone(const ::nebula::meta::cpp2::GetZoneReq& p_req) override; + void async_tm_getZone(std::unique_ptr> callback, const ::nebula::meta::cpp2::GetZoneReq& p_req) override; + virtual void listZones( ::nebula::meta::cpp2::ListZonesResp& /*_return*/, const ::nebula::meta::cpp2::ListZonesReq& /*req*/); + folly::Future< ::nebula::meta::cpp2::ListZonesResp> future_listZones(const ::nebula::meta::cpp2::ListZonesReq& p_req) override; + folly::SemiFuture< ::nebula::meta::cpp2::ListZonesResp> semifuture_listZones(const ::nebula::meta::cpp2::ListZonesReq& p_req) override; + void async_tm_listZones(std::unique_ptr> callback, const ::nebula::meta::cpp2::ListZonesReq& p_req) override; + virtual void addGroup( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::AddGroupReq& /*req*/); + folly::Future< ::nebula::meta::cpp2::ExecResp> future_addGroup(const ::nebula::meta::cpp2::AddGroupReq& p_req) override; + folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_addGroup(const ::nebula::meta::cpp2::AddGroupReq& p_req) override; + void async_tm_addGroup(std::unique_ptr> callback, const ::nebula::meta::cpp2::AddGroupReq& p_req) override; + virtual void dropGroup( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::DropGroupReq& /*req*/); + folly::Future< ::nebula::meta::cpp2::ExecResp> future_dropGroup(const ::nebula::meta::cpp2::DropGroupReq& p_req) override; + folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_dropGroup(const ::nebula::meta::cpp2::DropGroupReq& p_req) override; + void async_tm_dropGroup(std::unique_ptr> callback, const ::nebula::meta::cpp2::DropGroupReq& p_req) override; + virtual void addZoneIntoGroup( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::AddZoneIntoGroupReq& /*req*/); + folly::Future< ::nebula::meta::cpp2::ExecResp> future_addZoneIntoGroup(const ::nebula::meta::cpp2::AddZoneIntoGroupReq& p_req) override; + folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_addZoneIntoGroup(const ::nebula::meta::cpp2::AddZoneIntoGroupReq& p_req) override; + void async_tm_addZoneIntoGroup(std::unique_ptr> callback, const ::nebula::meta::cpp2::AddZoneIntoGroupReq& p_req) override; + virtual void dropZoneFromGroup( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::DropZoneFromGroupReq& /*req*/); + folly::Future< ::nebula::meta::cpp2::ExecResp> future_dropZoneFromGroup(const ::nebula::meta::cpp2::DropZoneFromGroupReq& p_req) override; + folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_dropZoneFromGroup(const ::nebula::meta::cpp2::DropZoneFromGroupReq& p_req) override; + void async_tm_dropZoneFromGroup(std::unique_ptr> callback, const ::nebula::meta::cpp2::DropZoneFromGroupReq& p_req) override; + virtual void getGroup( ::nebula::meta::cpp2::GetGroupResp& /*_return*/, const ::nebula::meta::cpp2::GetGroupReq& /*req*/); + folly::Future< ::nebula::meta::cpp2::GetGroupResp> future_getGroup(const ::nebula::meta::cpp2::GetGroupReq& p_req) override; + folly::SemiFuture< ::nebula::meta::cpp2::GetGroupResp> semifuture_getGroup(const ::nebula::meta::cpp2::GetGroupReq& p_req) override; + void async_tm_getGroup(std::unique_ptr> callback, const ::nebula::meta::cpp2::GetGroupReq& p_req) override; + virtual void listGroups( ::nebula::meta::cpp2::ListGroupsResp& /*_return*/, const ::nebula::meta::cpp2::ListGroupsReq& /*req*/); + folly::Future< ::nebula::meta::cpp2::ListGroupsResp> future_listGroups(const ::nebula::meta::cpp2::ListGroupsReq& p_req) override; + folly::SemiFuture< ::nebula::meta::cpp2::ListGroupsResp> semifuture_listGroups(const ::nebula::meta::cpp2::ListGroupsReq& p_req) override; + void async_tm_listGroups(std::unique_ptr> callback, const ::nebula::meta::cpp2::ListGroupsReq& p_req) override; + virtual void createBackup( ::nebula::meta::cpp2::CreateBackupResp& /*_return*/, const ::nebula::meta::cpp2::CreateBackupReq& /*req*/); + folly::Future< ::nebula::meta::cpp2::CreateBackupResp> future_createBackup(const ::nebula::meta::cpp2::CreateBackupReq& p_req) override; + folly::SemiFuture< ::nebula::meta::cpp2::CreateBackupResp> semifuture_createBackup(const ::nebula::meta::cpp2::CreateBackupReq& p_req) override; + void async_tm_createBackup(std::unique_ptr> callback, const ::nebula::meta::cpp2::CreateBackupReq& p_req) override; + virtual void restoreMeta( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::RestoreMetaReq& /*req*/); + folly::Future< ::nebula::meta::cpp2::ExecResp> future_restoreMeta(const ::nebula::meta::cpp2::RestoreMetaReq& p_req) override; + folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_restoreMeta(const ::nebula::meta::cpp2::RestoreMetaReq& p_req) override; + void async_tm_restoreMeta(std::unique_ptr> callback, const ::nebula::meta::cpp2::RestoreMetaReq& p_req) override; + virtual void addListener( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::AddListenerReq& /*req*/); + folly::Future< ::nebula::meta::cpp2::ExecResp> future_addListener(const ::nebula::meta::cpp2::AddListenerReq& p_req) override; + folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_addListener(const ::nebula::meta::cpp2::AddListenerReq& p_req) override; + void async_tm_addListener(std::unique_ptr> callback, const ::nebula::meta::cpp2::AddListenerReq& p_req) override; + virtual void removeListener( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::RemoveListenerReq& /*req*/); + folly::Future< ::nebula::meta::cpp2::ExecResp> future_removeListener(const ::nebula::meta::cpp2::RemoveListenerReq& p_req) override; + folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_removeListener(const ::nebula::meta::cpp2::RemoveListenerReq& p_req) override; + void async_tm_removeListener(std::unique_ptr> callback, const ::nebula::meta::cpp2::RemoveListenerReq& p_req) override; + virtual void listListener( ::nebula::meta::cpp2::ListListenerResp& /*_return*/, const ::nebula::meta::cpp2::ListListenerReq& /*req*/); + folly::Future< ::nebula::meta::cpp2::ListListenerResp> future_listListener(const ::nebula::meta::cpp2::ListListenerReq& p_req) override; + folly::SemiFuture< ::nebula::meta::cpp2::ListListenerResp> semifuture_listListener(const ::nebula::meta::cpp2::ListListenerReq& p_req) override; + void async_tm_listListener(std::unique_ptr> callback, const ::nebula::meta::cpp2::ListListenerReq& p_req) override; + virtual void getStats( ::nebula::meta::cpp2::GetStatsResp& /*_return*/, const ::nebula::meta::cpp2::GetStatsReq& /*req*/); + folly::Future< ::nebula::meta::cpp2::GetStatsResp> future_getStats(const ::nebula::meta::cpp2::GetStatsReq& p_req) override; + folly::SemiFuture< ::nebula::meta::cpp2::GetStatsResp> semifuture_getStats(const ::nebula::meta::cpp2::GetStatsReq& p_req) override; + void async_tm_getStats(std::unique_ptr> callback, const ::nebula::meta::cpp2::GetStatsReq& p_req) override; + virtual void signInFTService( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::SignInFTServiceReq& /*req*/); + folly::Future< ::nebula::meta::cpp2::ExecResp> future_signInFTService(const ::nebula::meta::cpp2::SignInFTServiceReq& p_req) override; + folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_signInFTService(const ::nebula::meta::cpp2::SignInFTServiceReq& p_req) override; + void async_tm_signInFTService(std::unique_ptr> callback, const ::nebula::meta::cpp2::SignInFTServiceReq& p_req) override; + virtual void signOutFTService( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::SignOutFTServiceReq& /*req*/); + folly::Future< ::nebula::meta::cpp2::ExecResp> future_signOutFTService(const ::nebula::meta::cpp2::SignOutFTServiceReq& p_req) override; + folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_signOutFTService(const ::nebula::meta::cpp2::SignOutFTServiceReq& p_req) override; + void async_tm_signOutFTService(std::unique_ptr> callback, const ::nebula::meta::cpp2::SignOutFTServiceReq& p_req) override; + virtual void listFTClients( ::nebula::meta::cpp2::ListFTClientsResp& /*_return*/, const ::nebula::meta::cpp2::ListFTClientsReq& /*req*/); + folly::Future< ::nebula::meta::cpp2::ListFTClientsResp> future_listFTClients(const ::nebula::meta::cpp2::ListFTClientsReq& p_req) override; + folly::SemiFuture< ::nebula::meta::cpp2::ListFTClientsResp> semifuture_listFTClients(const ::nebula::meta::cpp2::ListFTClientsReq& p_req) override; + void async_tm_listFTClients(std::unique_ptr> callback, const ::nebula::meta::cpp2::ListFTClientsReq& p_req) override; + virtual void createFTIndex( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::CreateFTIndexReq& /*req*/); + folly::Future< ::nebula::meta::cpp2::ExecResp> future_createFTIndex(const ::nebula::meta::cpp2::CreateFTIndexReq& p_req) override; + folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_createFTIndex(const ::nebula::meta::cpp2::CreateFTIndexReq& p_req) override; + void async_tm_createFTIndex(std::unique_ptr> callback, const ::nebula::meta::cpp2::CreateFTIndexReq& p_req) override; + virtual void dropFTIndex( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::DropFTIndexReq& /*req*/); + folly::Future< ::nebula::meta::cpp2::ExecResp> future_dropFTIndex(const ::nebula::meta::cpp2::DropFTIndexReq& p_req) override; + folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_dropFTIndex(const ::nebula::meta::cpp2::DropFTIndexReq& p_req) override; + void async_tm_dropFTIndex(std::unique_ptr> callback, const ::nebula::meta::cpp2::DropFTIndexReq& p_req) override; + virtual void listFTIndexes( ::nebula::meta::cpp2::ListFTIndexesResp& /*_return*/, const ::nebula::meta::cpp2::ListFTIndexesReq& /*req*/); + folly::Future< ::nebula::meta::cpp2::ListFTIndexesResp> future_listFTIndexes(const ::nebula::meta::cpp2::ListFTIndexesReq& p_req) override; + folly::SemiFuture< ::nebula::meta::cpp2::ListFTIndexesResp> semifuture_listFTIndexes(const ::nebula::meta::cpp2::ListFTIndexesReq& p_req) override; + void async_tm_listFTIndexes(std::unique_ptr> callback, const ::nebula::meta::cpp2::ListFTIndexesReq& p_req) override; + virtual void createSession( ::nebula::meta::cpp2::CreateSessionResp& /*_return*/, const ::nebula::meta::cpp2::CreateSessionReq& /*req*/); + folly::Future< ::nebula::meta::cpp2::CreateSessionResp> future_createSession(const ::nebula::meta::cpp2::CreateSessionReq& p_req) override; + folly::SemiFuture< ::nebula::meta::cpp2::CreateSessionResp> semifuture_createSession(const ::nebula::meta::cpp2::CreateSessionReq& p_req) override; + void async_tm_createSession(std::unique_ptr> callback, const ::nebula::meta::cpp2::CreateSessionReq& p_req) override; + virtual void updateSessions( ::nebula::meta::cpp2::UpdateSessionsResp& /*_return*/, const ::nebula::meta::cpp2::UpdateSessionsReq& /*req*/); + folly::Future< ::nebula::meta::cpp2::UpdateSessionsResp> future_updateSessions(const ::nebula::meta::cpp2::UpdateSessionsReq& p_req) override; + folly::SemiFuture< ::nebula::meta::cpp2::UpdateSessionsResp> semifuture_updateSessions(const ::nebula::meta::cpp2::UpdateSessionsReq& p_req) override; + void async_tm_updateSessions(std::unique_ptr> callback, const ::nebula::meta::cpp2::UpdateSessionsReq& p_req) override; + virtual void listSessions( ::nebula::meta::cpp2::ListSessionsResp& /*_return*/, const ::nebula::meta::cpp2::ListSessionsReq& /*req*/); + folly::Future< ::nebula::meta::cpp2::ListSessionsResp> future_listSessions(const ::nebula::meta::cpp2::ListSessionsReq& p_req) override; + folly::SemiFuture< ::nebula::meta::cpp2::ListSessionsResp> semifuture_listSessions(const ::nebula::meta::cpp2::ListSessionsReq& p_req) override; + void async_tm_listSessions(std::unique_ptr> callback, const ::nebula::meta::cpp2::ListSessionsReq& p_req) override; + virtual void getSession( ::nebula::meta::cpp2::GetSessionResp& /*_return*/, const ::nebula::meta::cpp2::GetSessionReq& /*req*/); + folly::Future< ::nebula::meta::cpp2::GetSessionResp> future_getSession(const ::nebula::meta::cpp2::GetSessionReq& p_req) override; + folly::SemiFuture< ::nebula::meta::cpp2::GetSessionResp> semifuture_getSession(const ::nebula::meta::cpp2::GetSessionReq& p_req) override; + void async_tm_getSession(std::unique_ptr> callback, const ::nebula::meta::cpp2::GetSessionReq& p_req) override; + virtual void removeSession( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::RemoveSessionReq& /*req*/); + folly::Future< ::nebula::meta::cpp2::ExecResp> future_removeSession(const ::nebula::meta::cpp2::RemoveSessionReq& p_req) override; + folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_removeSession(const ::nebula::meta::cpp2::RemoveSessionReq& p_req) override; + void async_tm_removeSession(std::unique_ptr> callback, const ::nebula::meta::cpp2::RemoveSessionReq& p_req) override; + virtual void killQuery( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::KillQueryReq& /*req*/); + folly::Future< ::nebula::meta::cpp2::ExecResp> future_killQuery(const ::nebula::meta::cpp2::KillQueryReq& p_req) override; + folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_killQuery(const ::nebula::meta::cpp2::KillQueryReq& p_req) override; + void async_tm_killQuery(std::unique_ptr> callback, const ::nebula::meta::cpp2::KillQueryReq& p_req) override; + virtual void reportTaskFinish( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::ReportTaskReq& /*req*/); + folly::Future< ::nebula::meta::cpp2::ExecResp> future_reportTaskFinish(const ::nebula::meta::cpp2::ReportTaskReq& p_req) override; + folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_reportTaskFinish(const ::nebula::meta::cpp2::ReportTaskReq& p_req) override; + void async_tm_reportTaskFinish(std::unique_ptr> callback, const ::nebula::meta::cpp2::ReportTaskReq& p_req) override; + virtual void listCluster( ::nebula::meta::cpp2::ListClusterInfoResp& /*_return*/, const ::nebula::meta::cpp2::ListClusterInfoReq& /*req*/); + folly::Future< ::nebula::meta::cpp2::ListClusterInfoResp> future_listCluster(const ::nebula::meta::cpp2::ListClusterInfoReq& p_req) override; + folly::SemiFuture< ::nebula::meta::cpp2::ListClusterInfoResp> semifuture_listCluster(const ::nebula::meta::cpp2::ListClusterInfoReq& p_req) override; + void async_tm_listCluster(std::unique_ptr> callback, const ::nebula::meta::cpp2::ListClusterInfoReq& p_req) override; + virtual void getMetaDirInfo( ::nebula::meta::cpp2::GetMetaDirInfoResp& /*_return*/, const ::nebula::meta::cpp2::GetMetaDirInfoReq& /*req*/); + folly::Future< ::nebula::meta::cpp2::GetMetaDirInfoResp> future_getMetaDirInfo(const ::nebula::meta::cpp2::GetMetaDirInfoReq& p_req) override; + folly::SemiFuture< ::nebula::meta::cpp2::GetMetaDirInfoResp> semifuture_getMetaDirInfo(const ::nebula::meta::cpp2::GetMetaDirInfoReq& p_req) override; + void async_tm_getMetaDirInfo(std::unique_ptr> callback, const ::nebula::meta::cpp2::GetMetaDirInfoReq& p_req) override; + virtual void verifyClientVersion( ::nebula::meta::cpp2::VerifyClientVersionResp& /*_return*/, const ::nebula::meta::cpp2::VerifyClientVersionReq& /*req*/); + folly::Future< ::nebula::meta::cpp2::VerifyClientVersionResp> future_verifyClientVersion(const ::nebula::meta::cpp2::VerifyClientVersionReq& p_req) override; + folly::SemiFuture< ::nebula::meta::cpp2::VerifyClientVersionResp> semifuture_verifyClientVersion(const ::nebula::meta::cpp2::VerifyClientVersionReq& p_req) override; + void async_tm_verifyClientVersion(std::unique_ptr> callback, const ::nebula::meta::cpp2::VerifyClientVersionReq& p_req) override; +}; + +class MetaServiceSvNull : public MetaServiceSvIf { + public: + void createSpace( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::CreateSpaceReq& /*req*/) override; + void dropSpace( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::DropSpaceReq& /*req*/) override; + void getSpace( ::nebula::meta::cpp2::GetSpaceResp& /*_return*/, const ::nebula::meta::cpp2::GetSpaceReq& /*req*/) override; + void listSpaces( ::nebula::meta::cpp2::ListSpacesResp& /*_return*/, const ::nebula::meta::cpp2::ListSpacesReq& /*req*/) override; + void createSpaceAs( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::CreateSpaceAsReq& /*req*/) override; + void createTag( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::CreateTagReq& /*req*/) override; + void alterTag( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::AlterTagReq& /*req*/) override; + void dropTag( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::DropTagReq& /*req*/) override; + void getTag( ::nebula::meta::cpp2::GetTagResp& /*_return*/, const ::nebula::meta::cpp2::GetTagReq& /*req*/) override; + void listTags( ::nebula::meta::cpp2::ListTagsResp& /*_return*/, const ::nebula::meta::cpp2::ListTagsReq& /*req*/) override; + void createEdge( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::CreateEdgeReq& /*req*/) override; + void alterEdge( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::AlterEdgeReq& /*req*/) override; + void dropEdge( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::DropEdgeReq& /*req*/) override; + void getEdge( ::nebula::meta::cpp2::GetEdgeResp& /*_return*/, const ::nebula::meta::cpp2::GetEdgeReq& /*req*/) override; + void listEdges( ::nebula::meta::cpp2::ListEdgesResp& /*_return*/, const ::nebula::meta::cpp2::ListEdgesReq& /*req*/) override; + void listHosts( ::nebula::meta::cpp2::ListHostsResp& /*_return*/, const ::nebula::meta::cpp2::ListHostsReq& /*req*/) override; + void getPartsAlloc( ::nebula::meta::cpp2::GetPartsAllocResp& /*_return*/, const ::nebula::meta::cpp2::GetPartsAllocReq& /*req*/) override; + void listParts( ::nebula::meta::cpp2::ListPartsResp& /*_return*/, const ::nebula::meta::cpp2::ListPartsReq& /*req*/) override; + void multiPut( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::MultiPutReq& /*req*/) override; + void get( ::nebula::meta::cpp2::GetResp& /*_return*/, const ::nebula::meta::cpp2::GetReq& /*req*/) override; + void multiGet( ::nebula::meta::cpp2::MultiGetResp& /*_return*/, const ::nebula::meta::cpp2::MultiGetReq& /*req*/) override; + void remove( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::RemoveReq& /*req*/) override; + void removeRange( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::RemoveRangeReq& /*req*/) override; + void scan( ::nebula::meta::cpp2::ScanResp& /*_return*/, const ::nebula::meta::cpp2::ScanReq& /*req*/) override; + void createTagIndex( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::CreateTagIndexReq& /*req*/) override; + void dropTagIndex( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::DropTagIndexReq& /*req*/) override; + void getTagIndex( ::nebula::meta::cpp2::GetTagIndexResp& /*_return*/, const ::nebula::meta::cpp2::GetTagIndexReq& /*req*/) override; + void listTagIndexes( ::nebula::meta::cpp2::ListTagIndexesResp& /*_return*/, const ::nebula::meta::cpp2::ListTagIndexesReq& /*req*/) override; + void rebuildTagIndex( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::RebuildIndexReq& /*req*/) override; + void listTagIndexStatus( ::nebula::meta::cpp2::ListIndexStatusResp& /*_return*/, const ::nebula::meta::cpp2::ListIndexStatusReq& /*req*/) override; + void createEdgeIndex( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::CreateEdgeIndexReq& /*req*/) override; + void dropEdgeIndex( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::DropEdgeIndexReq& /*req*/) override; + void getEdgeIndex( ::nebula::meta::cpp2::GetEdgeIndexResp& /*_return*/, const ::nebula::meta::cpp2::GetEdgeIndexReq& /*req*/) override; + void listEdgeIndexes( ::nebula::meta::cpp2::ListEdgeIndexesResp& /*_return*/, const ::nebula::meta::cpp2::ListEdgeIndexesReq& /*req*/) override; + void rebuildEdgeIndex( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::RebuildIndexReq& /*req*/) override; + void listEdgeIndexStatus( ::nebula::meta::cpp2::ListIndexStatusResp& /*_return*/, const ::nebula::meta::cpp2::ListIndexStatusReq& /*req*/) override; + void createUser( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::CreateUserReq& /*req*/) override; + void dropUser( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::DropUserReq& /*req*/) override; + void alterUser( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::AlterUserReq& /*req*/) override; + void grantRole( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::GrantRoleReq& /*req*/) override; + void revokeRole( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::RevokeRoleReq& /*req*/) override; + void listUsers( ::nebula::meta::cpp2::ListUsersResp& /*_return*/, const ::nebula::meta::cpp2::ListUsersReq& /*req*/) override; + void listRoles( ::nebula::meta::cpp2::ListRolesResp& /*_return*/, const ::nebula::meta::cpp2::ListRolesReq& /*req*/) override; + void getUserRoles( ::nebula::meta::cpp2::ListRolesResp& /*_return*/, const ::nebula::meta::cpp2::GetUserRolesReq& /*req*/) override; + void changePassword( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::ChangePasswordReq& /*req*/) override; + void heartBeat( ::nebula::meta::cpp2::HBResp& /*_return*/, const ::nebula::meta::cpp2::HBReq& /*req*/) override; + void balance( ::nebula::meta::cpp2::BalanceResp& /*_return*/, const ::nebula::meta::cpp2::BalanceReq& /*req*/) override; + void leaderBalance( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::LeaderBalanceReq& /*req*/) override; + void regConfig( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::RegConfigReq& /*req*/) override; + void getConfig( ::nebula::meta::cpp2::GetConfigResp& /*_return*/, const ::nebula::meta::cpp2::GetConfigReq& /*req*/) override; + void setConfig( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::SetConfigReq& /*req*/) override; + void listConfigs( ::nebula::meta::cpp2::ListConfigsResp& /*_return*/, const ::nebula::meta::cpp2::ListConfigsReq& /*req*/) override; + void createSnapshot( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::CreateSnapshotReq& /*req*/) override; + void dropSnapshot( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::DropSnapshotReq& /*req*/) override; + void listSnapshots( ::nebula::meta::cpp2::ListSnapshotsResp& /*_return*/, const ::nebula::meta::cpp2::ListSnapshotsReq& /*req*/) override; + void runAdminJob( ::nebula::meta::cpp2::AdminJobResp& /*_return*/, const ::nebula::meta::cpp2::AdminJobReq& /*req*/) override; + void addZone( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::AddZoneReq& /*req*/) override; + void dropZone( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::DropZoneReq& /*req*/) override; + void addHostIntoZone( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::AddHostIntoZoneReq& /*req*/) override; + void dropHostFromZone( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::DropHostFromZoneReq& /*req*/) override; + void getZone( ::nebula::meta::cpp2::GetZoneResp& /*_return*/, const ::nebula::meta::cpp2::GetZoneReq& /*req*/) override; + void listZones( ::nebula::meta::cpp2::ListZonesResp& /*_return*/, const ::nebula::meta::cpp2::ListZonesReq& /*req*/) override; + void addGroup( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::AddGroupReq& /*req*/) override; + void dropGroup( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::DropGroupReq& /*req*/) override; + void addZoneIntoGroup( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::AddZoneIntoGroupReq& /*req*/) override; + void dropZoneFromGroup( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::DropZoneFromGroupReq& /*req*/) override; + void getGroup( ::nebula::meta::cpp2::GetGroupResp& /*_return*/, const ::nebula::meta::cpp2::GetGroupReq& /*req*/) override; + void listGroups( ::nebula::meta::cpp2::ListGroupsResp& /*_return*/, const ::nebula::meta::cpp2::ListGroupsReq& /*req*/) override; + void createBackup( ::nebula::meta::cpp2::CreateBackupResp& /*_return*/, const ::nebula::meta::cpp2::CreateBackupReq& /*req*/) override; + void restoreMeta( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::RestoreMetaReq& /*req*/) override; + void addListener( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::AddListenerReq& /*req*/) override; + void removeListener( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::RemoveListenerReq& /*req*/) override; + void listListener( ::nebula::meta::cpp2::ListListenerResp& /*_return*/, const ::nebula::meta::cpp2::ListListenerReq& /*req*/) override; + void getStats( ::nebula::meta::cpp2::GetStatsResp& /*_return*/, const ::nebula::meta::cpp2::GetStatsReq& /*req*/) override; + void signInFTService( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::SignInFTServiceReq& /*req*/) override; + void signOutFTService( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::SignOutFTServiceReq& /*req*/) override; + void listFTClients( ::nebula::meta::cpp2::ListFTClientsResp& /*_return*/, const ::nebula::meta::cpp2::ListFTClientsReq& /*req*/) override; + void createFTIndex( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::CreateFTIndexReq& /*req*/) override; + void dropFTIndex( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::DropFTIndexReq& /*req*/) override; + void listFTIndexes( ::nebula::meta::cpp2::ListFTIndexesResp& /*_return*/, const ::nebula::meta::cpp2::ListFTIndexesReq& /*req*/) override; + void createSession( ::nebula::meta::cpp2::CreateSessionResp& /*_return*/, const ::nebula::meta::cpp2::CreateSessionReq& /*req*/) override; + void updateSessions( ::nebula::meta::cpp2::UpdateSessionsResp& /*_return*/, const ::nebula::meta::cpp2::UpdateSessionsReq& /*req*/) override; + void listSessions( ::nebula::meta::cpp2::ListSessionsResp& /*_return*/, const ::nebula::meta::cpp2::ListSessionsReq& /*req*/) override; + void getSession( ::nebula::meta::cpp2::GetSessionResp& /*_return*/, const ::nebula::meta::cpp2::GetSessionReq& /*req*/) override; + void removeSession( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::RemoveSessionReq& /*req*/) override; + void killQuery( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::KillQueryReq& /*req*/) override; + void reportTaskFinish( ::nebula::meta::cpp2::ExecResp& /*_return*/, const ::nebula::meta::cpp2::ReportTaskReq& /*req*/) override; + void listCluster( ::nebula::meta::cpp2::ListClusterInfoResp& /*_return*/, const ::nebula::meta::cpp2::ListClusterInfoReq& /*req*/) override; + void getMetaDirInfo( ::nebula::meta::cpp2::GetMetaDirInfoResp& /*_return*/, const ::nebula::meta::cpp2::GetMetaDirInfoReq& /*req*/) override; + void verifyClientVersion( ::nebula::meta::cpp2::VerifyClientVersionResp& /*_return*/, const ::nebula::meta::cpp2::VerifyClientVersionReq& /*req*/) override; +}; + +class MetaServiceAsyncProcessor : public ::apache::thrift::GeneratedAsyncProcessor { + public: + const char* getServiceName() override; + void getServiceMetadata(apache::thrift::metadata::ThriftServiceMetadataResponse& response) override; + using BaseAsyncProcessor = void; + protected: + MetaServiceSvIf* iface_; + public: + void processSerializedRequest(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::protocol::PROTOCOL_TYPES protType, apache::thrift::Cpp2RequestContext* context, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) override; + protected: + std::shared_ptr getBaseContextForRequest() override; + public: + using ProcessFunc = GeneratedAsyncProcessor::ProcessFunc; + using ProcessMap = GeneratedAsyncProcessor::ProcessMap; + static const MetaServiceAsyncProcessor::ProcessMap& getBinaryProtocolProcessMap(); + static const MetaServiceAsyncProcessor::ProcessMap& getCompactProtocolProcessMap(); + private: + static const MetaServiceAsyncProcessor::ProcessMap binaryProcessMap_; + static const MetaServiceAsyncProcessor::ProcessMap compactProcessMap_; + private: + template + void setUpAndProcess_createSpace(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_createSpace(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_createSpace(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ExecResp const& _return); + template + static void throw_wrapped_createSpace(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_dropSpace(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_dropSpace(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_dropSpace(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ExecResp const& _return); + template + static void throw_wrapped_dropSpace(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_getSpace(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_getSpace(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_getSpace(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::GetSpaceResp const& _return); + template + static void throw_wrapped_getSpace(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_listSpaces(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_listSpaces(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_listSpaces(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ListSpacesResp const& _return); + template + static void throw_wrapped_listSpaces(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_createSpaceAs(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_createSpaceAs(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_createSpaceAs(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ExecResp const& _return); + template + static void throw_wrapped_createSpaceAs(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_createTag(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_createTag(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_createTag(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ExecResp const& _return); + template + static void throw_wrapped_createTag(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_alterTag(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_alterTag(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_alterTag(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ExecResp const& _return); + template + static void throw_wrapped_alterTag(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_dropTag(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_dropTag(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_dropTag(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ExecResp const& _return); + template + static void throw_wrapped_dropTag(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_getTag(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_getTag(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_getTag(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::GetTagResp const& _return); + template + static void throw_wrapped_getTag(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_listTags(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_listTags(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_listTags(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ListTagsResp const& _return); + template + static void throw_wrapped_listTags(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_createEdge(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_createEdge(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_createEdge(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ExecResp const& _return); + template + static void throw_wrapped_createEdge(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_alterEdge(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_alterEdge(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_alterEdge(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ExecResp const& _return); + template + static void throw_wrapped_alterEdge(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_dropEdge(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_dropEdge(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_dropEdge(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ExecResp const& _return); + template + static void throw_wrapped_dropEdge(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_getEdge(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_getEdge(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_getEdge(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::GetEdgeResp const& _return); + template + static void throw_wrapped_getEdge(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_listEdges(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_listEdges(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_listEdges(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ListEdgesResp const& _return); + template + static void throw_wrapped_listEdges(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_listHosts(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_listHosts(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_listHosts(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ListHostsResp const& _return); + template + static void throw_wrapped_listHosts(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_getPartsAlloc(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_getPartsAlloc(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_getPartsAlloc(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::GetPartsAllocResp const& _return); + template + static void throw_wrapped_getPartsAlloc(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_listParts(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_listParts(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_listParts(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ListPartsResp const& _return); + template + static void throw_wrapped_listParts(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_multiPut(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_multiPut(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_multiPut(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ExecResp const& _return); + template + static void throw_wrapped_multiPut(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_get(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_get(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_get(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::GetResp const& _return); + template + static void throw_wrapped_get(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_multiGet(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_multiGet(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_multiGet(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::MultiGetResp const& _return); + template + static void throw_wrapped_multiGet(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_remove(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_remove(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_remove(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ExecResp const& _return); + template + static void throw_wrapped_remove(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_removeRange(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_removeRange(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_removeRange(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ExecResp const& _return); + template + static void throw_wrapped_removeRange(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_scan(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_scan(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_scan(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ScanResp const& _return); + template + static void throw_wrapped_scan(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_createTagIndex(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_createTagIndex(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_createTagIndex(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ExecResp const& _return); + template + static void throw_wrapped_createTagIndex(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_dropTagIndex(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_dropTagIndex(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_dropTagIndex(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ExecResp const& _return); + template + static void throw_wrapped_dropTagIndex(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_getTagIndex(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_getTagIndex(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_getTagIndex(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::GetTagIndexResp const& _return); + template + static void throw_wrapped_getTagIndex(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_listTagIndexes(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_listTagIndexes(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_listTagIndexes(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ListTagIndexesResp const& _return); + template + static void throw_wrapped_listTagIndexes(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_rebuildTagIndex(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_rebuildTagIndex(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_rebuildTagIndex(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ExecResp const& _return); + template + static void throw_wrapped_rebuildTagIndex(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_listTagIndexStatus(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_listTagIndexStatus(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_listTagIndexStatus(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ListIndexStatusResp const& _return); + template + static void throw_wrapped_listTagIndexStatus(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_createEdgeIndex(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_createEdgeIndex(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_createEdgeIndex(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ExecResp const& _return); + template + static void throw_wrapped_createEdgeIndex(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_dropEdgeIndex(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_dropEdgeIndex(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_dropEdgeIndex(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ExecResp const& _return); + template + static void throw_wrapped_dropEdgeIndex(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_getEdgeIndex(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_getEdgeIndex(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_getEdgeIndex(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::GetEdgeIndexResp const& _return); + template + static void throw_wrapped_getEdgeIndex(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_listEdgeIndexes(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_listEdgeIndexes(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_listEdgeIndexes(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ListEdgeIndexesResp const& _return); + template + static void throw_wrapped_listEdgeIndexes(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_rebuildEdgeIndex(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_rebuildEdgeIndex(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_rebuildEdgeIndex(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ExecResp const& _return); + template + static void throw_wrapped_rebuildEdgeIndex(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_listEdgeIndexStatus(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_listEdgeIndexStatus(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_listEdgeIndexStatus(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ListIndexStatusResp const& _return); + template + static void throw_wrapped_listEdgeIndexStatus(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_createUser(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_createUser(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_createUser(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ExecResp const& _return); + template + static void throw_wrapped_createUser(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_dropUser(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_dropUser(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_dropUser(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ExecResp const& _return); + template + static void throw_wrapped_dropUser(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_alterUser(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_alterUser(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_alterUser(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ExecResp const& _return); + template + static void throw_wrapped_alterUser(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_grantRole(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_grantRole(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_grantRole(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ExecResp const& _return); + template + static void throw_wrapped_grantRole(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_revokeRole(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_revokeRole(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_revokeRole(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ExecResp const& _return); + template + static void throw_wrapped_revokeRole(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_listUsers(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_listUsers(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_listUsers(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ListUsersResp const& _return); + template + static void throw_wrapped_listUsers(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_listRoles(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_listRoles(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_listRoles(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ListRolesResp const& _return); + template + static void throw_wrapped_listRoles(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_getUserRoles(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_getUserRoles(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_getUserRoles(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ListRolesResp const& _return); + template + static void throw_wrapped_getUserRoles(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_changePassword(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_changePassword(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_changePassword(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ExecResp const& _return); + template + static void throw_wrapped_changePassword(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_heartBeat(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_heartBeat(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_heartBeat(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::HBResp const& _return); + template + static void throw_wrapped_heartBeat(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_balance(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_balance(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_balance(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::BalanceResp const& _return); + template + static void throw_wrapped_balance(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_leaderBalance(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_leaderBalance(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_leaderBalance(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ExecResp const& _return); + template + static void throw_wrapped_leaderBalance(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_regConfig(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_regConfig(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_regConfig(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ExecResp const& _return); + template + static void throw_wrapped_regConfig(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_getConfig(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_getConfig(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_getConfig(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::GetConfigResp const& _return); + template + static void throw_wrapped_getConfig(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_setConfig(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_setConfig(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_setConfig(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ExecResp const& _return); + template + static void throw_wrapped_setConfig(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_listConfigs(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_listConfigs(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_listConfigs(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ListConfigsResp const& _return); + template + static void throw_wrapped_listConfigs(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_createSnapshot(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_createSnapshot(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_createSnapshot(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ExecResp const& _return); + template + static void throw_wrapped_createSnapshot(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_dropSnapshot(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_dropSnapshot(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_dropSnapshot(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ExecResp const& _return); + template + static void throw_wrapped_dropSnapshot(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_listSnapshots(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_listSnapshots(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_listSnapshots(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ListSnapshotsResp const& _return); + template + static void throw_wrapped_listSnapshots(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_runAdminJob(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_runAdminJob(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_runAdminJob(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::AdminJobResp const& _return); + template + static void throw_wrapped_runAdminJob(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_addZone(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_addZone(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_addZone(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ExecResp const& _return); + template + static void throw_wrapped_addZone(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_dropZone(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_dropZone(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_dropZone(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ExecResp const& _return); + template + static void throw_wrapped_dropZone(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_addHostIntoZone(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_addHostIntoZone(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_addHostIntoZone(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ExecResp const& _return); + template + static void throw_wrapped_addHostIntoZone(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_dropHostFromZone(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_dropHostFromZone(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_dropHostFromZone(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ExecResp const& _return); + template + static void throw_wrapped_dropHostFromZone(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_getZone(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_getZone(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_getZone(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::GetZoneResp const& _return); + template + static void throw_wrapped_getZone(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_listZones(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_listZones(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_listZones(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ListZonesResp const& _return); + template + static void throw_wrapped_listZones(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_addGroup(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_addGroup(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_addGroup(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ExecResp const& _return); + template + static void throw_wrapped_addGroup(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_dropGroup(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_dropGroup(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_dropGroup(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ExecResp const& _return); + template + static void throw_wrapped_dropGroup(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_addZoneIntoGroup(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_addZoneIntoGroup(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_addZoneIntoGroup(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ExecResp const& _return); + template + static void throw_wrapped_addZoneIntoGroup(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_dropZoneFromGroup(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_dropZoneFromGroup(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_dropZoneFromGroup(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ExecResp const& _return); + template + static void throw_wrapped_dropZoneFromGroup(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_getGroup(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_getGroup(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_getGroup(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::GetGroupResp const& _return); + template + static void throw_wrapped_getGroup(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_listGroups(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_listGroups(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_listGroups(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ListGroupsResp const& _return); + template + static void throw_wrapped_listGroups(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_createBackup(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_createBackup(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_createBackup(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::CreateBackupResp const& _return); + template + static void throw_wrapped_createBackup(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_restoreMeta(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_restoreMeta(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_restoreMeta(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ExecResp const& _return); + template + static void throw_wrapped_restoreMeta(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_addListener(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_addListener(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_addListener(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ExecResp const& _return); + template + static void throw_wrapped_addListener(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_removeListener(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_removeListener(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_removeListener(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ExecResp const& _return); + template + static void throw_wrapped_removeListener(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_listListener(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_listListener(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_listListener(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ListListenerResp const& _return); + template + static void throw_wrapped_listListener(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_getStats(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_getStats(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_getStats(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::GetStatsResp const& _return); + template + static void throw_wrapped_getStats(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_signInFTService(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_signInFTService(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_signInFTService(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ExecResp const& _return); + template + static void throw_wrapped_signInFTService(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_signOutFTService(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_signOutFTService(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_signOutFTService(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ExecResp const& _return); + template + static void throw_wrapped_signOutFTService(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_listFTClients(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_listFTClients(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_listFTClients(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ListFTClientsResp const& _return); + template + static void throw_wrapped_listFTClients(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_createFTIndex(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_createFTIndex(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_createFTIndex(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ExecResp const& _return); + template + static void throw_wrapped_createFTIndex(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_dropFTIndex(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_dropFTIndex(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_dropFTIndex(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ExecResp const& _return); + template + static void throw_wrapped_dropFTIndex(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_listFTIndexes(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_listFTIndexes(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_listFTIndexes(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ListFTIndexesResp const& _return); + template + static void throw_wrapped_listFTIndexes(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_createSession(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_createSession(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_createSession(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::CreateSessionResp const& _return); + template + static void throw_wrapped_createSession(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_updateSessions(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_updateSessions(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_updateSessions(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::UpdateSessionsResp const& _return); + template + static void throw_wrapped_updateSessions(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_listSessions(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_listSessions(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_listSessions(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ListSessionsResp const& _return); + template + static void throw_wrapped_listSessions(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_getSession(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_getSession(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_getSession(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::GetSessionResp const& _return); + template + static void throw_wrapped_getSession(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_removeSession(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_removeSession(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_removeSession(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ExecResp const& _return); + template + static void throw_wrapped_removeSession(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_killQuery(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_killQuery(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_killQuery(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ExecResp const& _return); + template + static void throw_wrapped_killQuery(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_reportTaskFinish(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_reportTaskFinish(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_reportTaskFinish(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ExecResp const& _return); + template + static void throw_wrapped_reportTaskFinish(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_listCluster(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_listCluster(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_listCluster(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ListClusterInfoResp const& _return); + template + static void throw_wrapped_listCluster(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_getMetaDirInfo(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_getMetaDirInfo(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_getMetaDirInfo(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::GetMetaDirInfoResp const& _return); + template + static void throw_wrapped_getMetaDirInfo(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_verifyClientVersion(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_verifyClientVersion(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_verifyClientVersion(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::VerifyClientVersionResp const& _return); + template + static void throw_wrapped_verifyClientVersion(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + public: + MetaServiceAsyncProcessor(MetaServiceSvIf* iface) : + iface_(iface) {} + + virtual ~MetaServiceAsyncProcessor() {} +}; + +}}} // nebula::meta::cpp2 diff --git a/src/interface/gen-cpp2/MetaService.tcc b/src/interface/gen-cpp2/MetaService.tcc new file mode 100644 index 00000000..b4e7e88a --- /dev/null +++ b/src/interface/gen-cpp2/MetaService.tcc @@ -0,0 +1,5325 @@ +/** + * Autogenerated by Thrift for meta.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#pragma once + +#include "MetaService.h" + +#include + +namespace nebula { namespace meta { namespace cpp2 { +typedef apache::thrift::ThriftPresult> MetaService_createSpace_pargs; +typedef apache::thrift::ThriftPresult> MetaService_createSpace_presult; +typedef apache::thrift::ThriftPresult> MetaService_dropSpace_pargs; +typedef apache::thrift::ThriftPresult> MetaService_dropSpace_presult; +typedef apache::thrift::ThriftPresult> MetaService_getSpace_pargs; +typedef apache::thrift::ThriftPresult> MetaService_getSpace_presult; +typedef apache::thrift::ThriftPresult> MetaService_listSpaces_pargs; +typedef apache::thrift::ThriftPresult> MetaService_listSpaces_presult; +typedef apache::thrift::ThriftPresult> MetaService_createSpaceAs_pargs; +typedef apache::thrift::ThriftPresult> MetaService_createSpaceAs_presult; +typedef apache::thrift::ThriftPresult> MetaService_createTag_pargs; +typedef apache::thrift::ThriftPresult> MetaService_createTag_presult; +typedef apache::thrift::ThriftPresult> MetaService_alterTag_pargs; +typedef apache::thrift::ThriftPresult> MetaService_alterTag_presult; +typedef apache::thrift::ThriftPresult> MetaService_dropTag_pargs; +typedef apache::thrift::ThriftPresult> MetaService_dropTag_presult; +typedef apache::thrift::ThriftPresult> MetaService_getTag_pargs; +typedef apache::thrift::ThriftPresult> MetaService_getTag_presult; +typedef apache::thrift::ThriftPresult> MetaService_listTags_pargs; +typedef apache::thrift::ThriftPresult> MetaService_listTags_presult; +typedef apache::thrift::ThriftPresult> MetaService_createEdge_pargs; +typedef apache::thrift::ThriftPresult> MetaService_createEdge_presult; +typedef apache::thrift::ThriftPresult> MetaService_alterEdge_pargs; +typedef apache::thrift::ThriftPresult> MetaService_alterEdge_presult; +typedef apache::thrift::ThriftPresult> MetaService_dropEdge_pargs; +typedef apache::thrift::ThriftPresult> MetaService_dropEdge_presult; +typedef apache::thrift::ThriftPresult> MetaService_getEdge_pargs; +typedef apache::thrift::ThriftPresult> MetaService_getEdge_presult; +typedef apache::thrift::ThriftPresult> MetaService_listEdges_pargs; +typedef apache::thrift::ThriftPresult> MetaService_listEdges_presult; +typedef apache::thrift::ThriftPresult> MetaService_listHosts_pargs; +typedef apache::thrift::ThriftPresult> MetaService_listHosts_presult; +typedef apache::thrift::ThriftPresult> MetaService_getPartsAlloc_pargs; +typedef apache::thrift::ThriftPresult> MetaService_getPartsAlloc_presult; +typedef apache::thrift::ThriftPresult> MetaService_listParts_pargs; +typedef apache::thrift::ThriftPresult> MetaService_listParts_presult; +typedef apache::thrift::ThriftPresult> MetaService_multiPut_pargs; +typedef apache::thrift::ThriftPresult> MetaService_multiPut_presult; +typedef apache::thrift::ThriftPresult> MetaService_get_pargs; +typedef apache::thrift::ThriftPresult> MetaService_get_presult; +typedef apache::thrift::ThriftPresult> MetaService_multiGet_pargs; +typedef apache::thrift::ThriftPresult> MetaService_multiGet_presult; +typedef apache::thrift::ThriftPresult> MetaService_remove_pargs; +typedef apache::thrift::ThriftPresult> MetaService_remove_presult; +typedef apache::thrift::ThriftPresult> MetaService_removeRange_pargs; +typedef apache::thrift::ThriftPresult> MetaService_removeRange_presult; +typedef apache::thrift::ThriftPresult> MetaService_scan_pargs; +typedef apache::thrift::ThriftPresult> MetaService_scan_presult; +typedef apache::thrift::ThriftPresult> MetaService_createTagIndex_pargs; +typedef apache::thrift::ThriftPresult> MetaService_createTagIndex_presult; +typedef apache::thrift::ThriftPresult> MetaService_dropTagIndex_pargs; +typedef apache::thrift::ThriftPresult> MetaService_dropTagIndex_presult; +typedef apache::thrift::ThriftPresult> MetaService_getTagIndex_pargs; +typedef apache::thrift::ThriftPresult> MetaService_getTagIndex_presult; +typedef apache::thrift::ThriftPresult> MetaService_listTagIndexes_pargs; +typedef apache::thrift::ThriftPresult> MetaService_listTagIndexes_presult; +typedef apache::thrift::ThriftPresult> MetaService_rebuildTagIndex_pargs; +typedef apache::thrift::ThriftPresult> MetaService_rebuildTagIndex_presult; +typedef apache::thrift::ThriftPresult> MetaService_listTagIndexStatus_pargs; +typedef apache::thrift::ThriftPresult> MetaService_listTagIndexStatus_presult; +typedef apache::thrift::ThriftPresult> MetaService_createEdgeIndex_pargs; +typedef apache::thrift::ThriftPresult> MetaService_createEdgeIndex_presult; +typedef apache::thrift::ThriftPresult> MetaService_dropEdgeIndex_pargs; +typedef apache::thrift::ThriftPresult> MetaService_dropEdgeIndex_presult; +typedef apache::thrift::ThriftPresult> MetaService_getEdgeIndex_pargs; +typedef apache::thrift::ThriftPresult> MetaService_getEdgeIndex_presult; +typedef apache::thrift::ThriftPresult> MetaService_listEdgeIndexes_pargs; +typedef apache::thrift::ThriftPresult> MetaService_listEdgeIndexes_presult; +typedef apache::thrift::ThriftPresult> MetaService_rebuildEdgeIndex_pargs; +typedef apache::thrift::ThriftPresult> MetaService_rebuildEdgeIndex_presult; +typedef apache::thrift::ThriftPresult> MetaService_listEdgeIndexStatus_pargs; +typedef apache::thrift::ThriftPresult> MetaService_listEdgeIndexStatus_presult; +typedef apache::thrift::ThriftPresult> MetaService_createUser_pargs; +typedef apache::thrift::ThriftPresult> MetaService_createUser_presult; +typedef apache::thrift::ThriftPresult> MetaService_dropUser_pargs; +typedef apache::thrift::ThriftPresult> MetaService_dropUser_presult; +typedef apache::thrift::ThriftPresult> MetaService_alterUser_pargs; +typedef apache::thrift::ThriftPresult> MetaService_alterUser_presult; +typedef apache::thrift::ThriftPresult> MetaService_grantRole_pargs; +typedef apache::thrift::ThriftPresult> MetaService_grantRole_presult; +typedef apache::thrift::ThriftPresult> MetaService_revokeRole_pargs; +typedef apache::thrift::ThriftPresult> MetaService_revokeRole_presult; +typedef apache::thrift::ThriftPresult> MetaService_listUsers_pargs; +typedef apache::thrift::ThriftPresult> MetaService_listUsers_presult; +typedef apache::thrift::ThriftPresult> MetaService_listRoles_pargs; +typedef apache::thrift::ThriftPresult> MetaService_listRoles_presult; +typedef apache::thrift::ThriftPresult> MetaService_getUserRoles_pargs; +typedef apache::thrift::ThriftPresult> MetaService_getUserRoles_presult; +typedef apache::thrift::ThriftPresult> MetaService_changePassword_pargs; +typedef apache::thrift::ThriftPresult> MetaService_changePassword_presult; +typedef apache::thrift::ThriftPresult> MetaService_heartBeat_pargs; +typedef apache::thrift::ThriftPresult> MetaService_heartBeat_presult; +typedef apache::thrift::ThriftPresult> MetaService_balance_pargs; +typedef apache::thrift::ThriftPresult> MetaService_balance_presult; +typedef apache::thrift::ThriftPresult> MetaService_leaderBalance_pargs; +typedef apache::thrift::ThriftPresult> MetaService_leaderBalance_presult; +typedef apache::thrift::ThriftPresult> MetaService_regConfig_pargs; +typedef apache::thrift::ThriftPresult> MetaService_regConfig_presult; +typedef apache::thrift::ThriftPresult> MetaService_getConfig_pargs; +typedef apache::thrift::ThriftPresult> MetaService_getConfig_presult; +typedef apache::thrift::ThriftPresult> MetaService_setConfig_pargs; +typedef apache::thrift::ThriftPresult> MetaService_setConfig_presult; +typedef apache::thrift::ThriftPresult> MetaService_listConfigs_pargs; +typedef apache::thrift::ThriftPresult> MetaService_listConfigs_presult; +typedef apache::thrift::ThriftPresult> MetaService_createSnapshot_pargs; +typedef apache::thrift::ThriftPresult> MetaService_createSnapshot_presult; +typedef apache::thrift::ThriftPresult> MetaService_dropSnapshot_pargs; +typedef apache::thrift::ThriftPresult> MetaService_dropSnapshot_presult; +typedef apache::thrift::ThriftPresult> MetaService_listSnapshots_pargs; +typedef apache::thrift::ThriftPresult> MetaService_listSnapshots_presult; +typedef apache::thrift::ThriftPresult> MetaService_runAdminJob_pargs; +typedef apache::thrift::ThriftPresult> MetaService_runAdminJob_presult; +typedef apache::thrift::ThriftPresult> MetaService_addZone_pargs; +typedef apache::thrift::ThriftPresult> MetaService_addZone_presult; +typedef apache::thrift::ThriftPresult> MetaService_dropZone_pargs; +typedef apache::thrift::ThriftPresult> MetaService_dropZone_presult; +typedef apache::thrift::ThriftPresult> MetaService_addHostIntoZone_pargs; +typedef apache::thrift::ThriftPresult> MetaService_addHostIntoZone_presult; +typedef apache::thrift::ThriftPresult> MetaService_dropHostFromZone_pargs; +typedef apache::thrift::ThriftPresult> MetaService_dropHostFromZone_presult; +typedef apache::thrift::ThriftPresult> MetaService_getZone_pargs; +typedef apache::thrift::ThriftPresult> MetaService_getZone_presult; +typedef apache::thrift::ThriftPresult> MetaService_listZones_pargs; +typedef apache::thrift::ThriftPresult> MetaService_listZones_presult; +typedef apache::thrift::ThriftPresult> MetaService_addGroup_pargs; +typedef apache::thrift::ThriftPresult> MetaService_addGroup_presult; +typedef apache::thrift::ThriftPresult> MetaService_dropGroup_pargs; +typedef apache::thrift::ThriftPresult> MetaService_dropGroup_presult; +typedef apache::thrift::ThriftPresult> MetaService_addZoneIntoGroup_pargs; +typedef apache::thrift::ThriftPresult> MetaService_addZoneIntoGroup_presult; +typedef apache::thrift::ThriftPresult> MetaService_dropZoneFromGroup_pargs; +typedef apache::thrift::ThriftPresult> MetaService_dropZoneFromGroup_presult; +typedef apache::thrift::ThriftPresult> MetaService_getGroup_pargs; +typedef apache::thrift::ThriftPresult> MetaService_getGroup_presult; +typedef apache::thrift::ThriftPresult> MetaService_listGroups_pargs; +typedef apache::thrift::ThriftPresult> MetaService_listGroups_presult; +typedef apache::thrift::ThriftPresult> MetaService_createBackup_pargs; +typedef apache::thrift::ThriftPresult> MetaService_createBackup_presult; +typedef apache::thrift::ThriftPresult> MetaService_restoreMeta_pargs; +typedef apache::thrift::ThriftPresult> MetaService_restoreMeta_presult; +typedef apache::thrift::ThriftPresult> MetaService_addListener_pargs; +typedef apache::thrift::ThriftPresult> MetaService_addListener_presult; +typedef apache::thrift::ThriftPresult> MetaService_removeListener_pargs; +typedef apache::thrift::ThriftPresult> MetaService_removeListener_presult; +typedef apache::thrift::ThriftPresult> MetaService_listListener_pargs; +typedef apache::thrift::ThriftPresult> MetaService_listListener_presult; +typedef apache::thrift::ThriftPresult> MetaService_getStats_pargs; +typedef apache::thrift::ThriftPresult> MetaService_getStats_presult; +typedef apache::thrift::ThriftPresult> MetaService_signInFTService_pargs; +typedef apache::thrift::ThriftPresult> MetaService_signInFTService_presult; +typedef apache::thrift::ThriftPresult> MetaService_signOutFTService_pargs; +typedef apache::thrift::ThriftPresult> MetaService_signOutFTService_presult; +typedef apache::thrift::ThriftPresult> MetaService_listFTClients_pargs; +typedef apache::thrift::ThriftPresult> MetaService_listFTClients_presult; +typedef apache::thrift::ThriftPresult> MetaService_createFTIndex_pargs; +typedef apache::thrift::ThriftPresult> MetaService_createFTIndex_presult; +typedef apache::thrift::ThriftPresult> MetaService_dropFTIndex_pargs; +typedef apache::thrift::ThriftPresult> MetaService_dropFTIndex_presult; +typedef apache::thrift::ThriftPresult> MetaService_listFTIndexes_pargs; +typedef apache::thrift::ThriftPresult> MetaService_listFTIndexes_presult; +typedef apache::thrift::ThriftPresult> MetaService_createSession_pargs; +typedef apache::thrift::ThriftPresult> MetaService_createSession_presult; +typedef apache::thrift::ThriftPresult> MetaService_updateSessions_pargs; +typedef apache::thrift::ThriftPresult> MetaService_updateSessions_presult; +typedef apache::thrift::ThriftPresult> MetaService_listSessions_pargs; +typedef apache::thrift::ThriftPresult> MetaService_listSessions_presult; +typedef apache::thrift::ThriftPresult> MetaService_getSession_pargs; +typedef apache::thrift::ThriftPresult> MetaService_getSession_presult; +typedef apache::thrift::ThriftPresult> MetaService_removeSession_pargs; +typedef apache::thrift::ThriftPresult> MetaService_removeSession_presult; +typedef apache::thrift::ThriftPresult> MetaService_killQuery_pargs; +typedef apache::thrift::ThriftPresult> MetaService_killQuery_presult; +typedef apache::thrift::ThriftPresult> MetaService_reportTaskFinish_pargs; +typedef apache::thrift::ThriftPresult> MetaService_reportTaskFinish_presult; +typedef apache::thrift::ThriftPresult> MetaService_listCluster_pargs; +typedef apache::thrift::ThriftPresult> MetaService_listCluster_presult; +typedef apache::thrift::ThriftPresult> MetaService_getMetaDirInfo_pargs; +typedef apache::thrift::ThriftPresult> MetaService_getMetaDirInfo_presult; +typedef apache::thrift::ThriftPresult> MetaService_verifyClientVersion_pargs; +typedef apache::thrift::ThriftPresult> MetaService_verifyClientVersion_presult; +template +void MetaServiceAsyncProcessor::setUpAndProcess_createSpace(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &MetaServiceAsyncProcessor::process_createSpace, this); +} + +template +void MetaServiceAsyncProcessor::process_createSpace(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + MetaService_createSpace_pargs args; + ::nebula::meta::cpp2::CreateSpaceReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "MetaService.createSpace", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "createSpace"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_createSpace, throw_wrapped_createSpace, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_createSpace(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue MetaServiceAsyncProcessor::return_createSpace(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ExecResp const& _return) { + ProtocolOut_ prot; + MetaService_createSpace_presult result; + result.get<0>().value = const_cast< ::nebula::meta::cpp2::ExecResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("createSpace", &prot, protoSeqId, ctx, result); +} + +template +void MetaServiceAsyncProcessor::throw_wrapped_createSpace(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "createSpace"); + return; + } +} + +template +void MetaServiceAsyncProcessor::setUpAndProcess_dropSpace(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &MetaServiceAsyncProcessor::process_dropSpace, this); +} + +template +void MetaServiceAsyncProcessor::process_dropSpace(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + MetaService_dropSpace_pargs args; + ::nebula::meta::cpp2::DropSpaceReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "MetaService.dropSpace", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "dropSpace"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_dropSpace, throw_wrapped_dropSpace, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_dropSpace(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue MetaServiceAsyncProcessor::return_dropSpace(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ExecResp const& _return) { + ProtocolOut_ prot; + MetaService_dropSpace_presult result; + result.get<0>().value = const_cast< ::nebula::meta::cpp2::ExecResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("dropSpace", &prot, protoSeqId, ctx, result); +} + +template +void MetaServiceAsyncProcessor::throw_wrapped_dropSpace(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "dropSpace"); + return; + } +} + +template +void MetaServiceAsyncProcessor::setUpAndProcess_getSpace(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &MetaServiceAsyncProcessor::process_getSpace, this); +} + +template +void MetaServiceAsyncProcessor::process_getSpace(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + MetaService_getSpace_pargs args; + ::nebula::meta::cpp2::GetSpaceReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "MetaService.getSpace", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "getSpace"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_getSpace, throw_wrapped_getSpace, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_getSpace(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue MetaServiceAsyncProcessor::return_getSpace(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::GetSpaceResp const& _return) { + ProtocolOut_ prot; + MetaService_getSpace_presult result; + result.get<0>().value = const_cast< ::nebula::meta::cpp2::GetSpaceResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("getSpace", &prot, protoSeqId, ctx, result); +} + +template +void MetaServiceAsyncProcessor::throw_wrapped_getSpace(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "getSpace"); + return; + } +} + +template +void MetaServiceAsyncProcessor::setUpAndProcess_listSpaces(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &MetaServiceAsyncProcessor::process_listSpaces, this); +} + +template +void MetaServiceAsyncProcessor::process_listSpaces(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + MetaService_listSpaces_pargs args; + ::nebula::meta::cpp2::ListSpacesReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "MetaService.listSpaces", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "listSpaces"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_listSpaces, throw_wrapped_listSpaces, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_listSpaces(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue MetaServiceAsyncProcessor::return_listSpaces(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ListSpacesResp const& _return) { + ProtocolOut_ prot; + MetaService_listSpaces_presult result; + result.get<0>().value = const_cast< ::nebula::meta::cpp2::ListSpacesResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("listSpaces", &prot, protoSeqId, ctx, result); +} + +template +void MetaServiceAsyncProcessor::throw_wrapped_listSpaces(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "listSpaces"); + return; + } +} + +template +void MetaServiceAsyncProcessor::setUpAndProcess_createSpaceAs(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &MetaServiceAsyncProcessor::process_createSpaceAs, this); +} + +template +void MetaServiceAsyncProcessor::process_createSpaceAs(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + MetaService_createSpaceAs_pargs args; + ::nebula::meta::cpp2::CreateSpaceAsReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "MetaService.createSpaceAs", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "createSpaceAs"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_createSpaceAs, throw_wrapped_createSpaceAs, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_createSpaceAs(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue MetaServiceAsyncProcessor::return_createSpaceAs(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ExecResp const& _return) { + ProtocolOut_ prot; + MetaService_createSpaceAs_presult result; + result.get<0>().value = const_cast< ::nebula::meta::cpp2::ExecResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("createSpaceAs", &prot, protoSeqId, ctx, result); +} + +template +void MetaServiceAsyncProcessor::throw_wrapped_createSpaceAs(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "createSpaceAs"); + return; + } +} + +template +void MetaServiceAsyncProcessor::setUpAndProcess_createTag(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &MetaServiceAsyncProcessor::process_createTag, this); +} + +template +void MetaServiceAsyncProcessor::process_createTag(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + MetaService_createTag_pargs args; + ::nebula::meta::cpp2::CreateTagReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "MetaService.createTag", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "createTag"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_createTag, throw_wrapped_createTag, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_createTag(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue MetaServiceAsyncProcessor::return_createTag(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ExecResp const& _return) { + ProtocolOut_ prot; + MetaService_createTag_presult result; + result.get<0>().value = const_cast< ::nebula::meta::cpp2::ExecResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("createTag", &prot, protoSeqId, ctx, result); +} + +template +void MetaServiceAsyncProcessor::throw_wrapped_createTag(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "createTag"); + return; + } +} + +template +void MetaServiceAsyncProcessor::setUpAndProcess_alterTag(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &MetaServiceAsyncProcessor::process_alterTag, this); +} + +template +void MetaServiceAsyncProcessor::process_alterTag(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + MetaService_alterTag_pargs args; + ::nebula::meta::cpp2::AlterTagReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "MetaService.alterTag", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "alterTag"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_alterTag, throw_wrapped_alterTag, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_alterTag(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue MetaServiceAsyncProcessor::return_alterTag(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ExecResp const& _return) { + ProtocolOut_ prot; + MetaService_alterTag_presult result; + result.get<0>().value = const_cast< ::nebula::meta::cpp2::ExecResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("alterTag", &prot, protoSeqId, ctx, result); +} + +template +void MetaServiceAsyncProcessor::throw_wrapped_alterTag(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "alterTag"); + return; + } +} + +template +void MetaServiceAsyncProcessor::setUpAndProcess_dropTag(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &MetaServiceAsyncProcessor::process_dropTag, this); +} + +template +void MetaServiceAsyncProcessor::process_dropTag(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + MetaService_dropTag_pargs args; + ::nebula::meta::cpp2::DropTagReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "MetaService.dropTag", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "dropTag"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_dropTag, throw_wrapped_dropTag, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_dropTag(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue MetaServiceAsyncProcessor::return_dropTag(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ExecResp const& _return) { + ProtocolOut_ prot; + MetaService_dropTag_presult result; + result.get<0>().value = const_cast< ::nebula::meta::cpp2::ExecResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("dropTag", &prot, protoSeqId, ctx, result); +} + +template +void MetaServiceAsyncProcessor::throw_wrapped_dropTag(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "dropTag"); + return; + } +} + +template +void MetaServiceAsyncProcessor::setUpAndProcess_getTag(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &MetaServiceAsyncProcessor::process_getTag, this); +} + +template +void MetaServiceAsyncProcessor::process_getTag(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + MetaService_getTag_pargs args; + ::nebula::meta::cpp2::GetTagReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "MetaService.getTag", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "getTag"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_getTag, throw_wrapped_getTag, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_getTag(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue MetaServiceAsyncProcessor::return_getTag(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::GetTagResp const& _return) { + ProtocolOut_ prot; + MetaService_getTag_presult result; + result.get<0>().value = const_cast< ::nebula::meta::cpp2::GetTagResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("getTag", &prot, protoSeqId, ctx, result); +} + +template +void MetaServiceAsyncProcessor::throw_wrapped_getTag(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "getTag"); + return; + } +} + +template +void MetaServiceAsyncProcessor::setUpAndProcess_listTags(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &MetaServiceAsyncProcessor::process_listTags, this); +} + +template +void MetaServiceAsyncProcessor::process_listTags(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + MetaService_listTags_pargs args; + ::nebula::meta::cpp2::ListTagsReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "MetaService.listTags", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "listTags"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_listTags, throw_wrapped_listTags, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_listTags(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue MetaServiceAsyncProcessor::return_listTags(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ListTagsResp const& _return) { + ProtocolOut_ prot; + MetaService_listTags_presult result; + result.get<0>().value = const_cast< ::nebula::meta::cpp2::ListTagsResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("listTags", &prot, protoSeqId, ctx, result); +} + +template +void MetaServiceAsyncProcessor::throw_wrapped_listTags(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "listTags"); + return; + } +} + +template +void MetaServiceAsyncProcessor::setUpAndProcess_createEdge(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &MetaServiceAsyncProcessor::process_createEdge, this); +} + +template +void MetaServiceAsyncProcessor::process_createEdge(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + MetaService_createEdge_pargs args; + ::nebula::meta::cpp2::CreateEdgeReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "MetaService.createEdge", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "createEdge"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_createEdge, throw_wrapped_createEdge, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_createEdge(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue MetaServiceAsyncProcessor::return_createEdge(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ExecResp const& _return) { + ProtocolOut_ prot; + MetaService_createEdge_presult result; + result.get<0>().value = const_cast< ::nebula::meta::cpp2::ExecResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("createEdge", &prot, protoSeqId, ctx, result); +} + +template +void MetaServiceAsyncProcessor::throw_wrapped_createEdge(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "createEdge"); + return; + } +} + +template +void MetaServiceAsyncProcessor::setUpAndProcess_alterEdge(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &MetaServiceAsyncProcessor::process_alterEdge, this); +} + +template +void MetaServiceAsyncProcessor::process_alterEdge(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + MetaService_alterEdge_pargs args; + ::nebula::meta::cpp2::AlterEdgeReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "MetaService.alterEdge", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "alterEdge"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_alterEdge, throw_wrapped_alterEdge, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_alterEdge(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue MetaServiceAsyncProcessor::return_alterEdge(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ExecResp const& _return) { + ProtocolOut_ prot; + MetaService_alterEdge_presult result; + result.get<0>().value = const_cast< ::nebula::meta::cpp2::ExecResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("alterEdge", &prot, protoSeqId, ctx, result); +} + +template +void MetaServiceAsyncProcessor::throw_wrapped_alterEdge(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "alterEdge"); + return; + } +} + +template +void MetaServiceAsyncProcessor::setUpAndProcess_dropEdge(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &MetaServiceAsyncProcessor::process_dropEdge, this); +} + +template +void MetaServiceAsyncProcessor::process_dropEdge(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + MetaService_dropEdge_pargs args; + ::nebula::meta::cpp2::DropEdgeReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "MetaService.dropEdge", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "dropEdge"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_dropEdge, throw_wrapped_dropEdge, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_dropEdge(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue MetaServiceAsyncProcessor::return_dropEdge(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ExecResp const& _return) { + ProtocolOut_ prot; + MetaService_dropEdge_presult result; + result.get<0>().value = const_cast< ::nebula::meta::cpp2::ExecResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("dropEdge", &prot, protoSeqId, ctx, result); +} + +template +void MetaServiceAsyncProcessor::throw_wrapped_dropEdge(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "dropEdge"); + return; + } +} + +template +void MetaServiceAsyncProcessor::setUpAndProcess_getEdge(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &MetaServiceAsyncProcessor::process_getEdge, this); +} + +template +void MetaServiceAsyncProcessor::process_getEdge(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + MetaService_getEdge_pargs args; + ::nebula::meta::cpp2::GetEdgeReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "MetaService.getEdge", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "getEdge"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_getEdge, throw_wrapped_getEdge, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_getEdge(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue MetaServiceAsyncProcessor::return_getEdge(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::GetEdgeResp const& _return) { + ProtocolOut_ prot; + MetaService_getEdge_presult result; + result.get<0>().value = const_cast< ::nebula::meta::cpp2::GetEdgeResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("getEdge", &prot, protoSeqId, ctx, result); +} + +template +void MetaServiceAsyncProcessor::throw_wrapped_getEdge(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "getEdge"); + return; + } +} + +template +void MetaServiceAsyncProcessor::setUpAndProcess_listEdges(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &MetaServiceAsyncProcessor::process_listEdges, this); +} + +template +void MetaServiceAsyncProcessor::process_listEdges(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + MetaService_listEdges_pargs args; + ::nebula::meta::cpp2::ListEdgesReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "MetaService.listEdges", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "listEdges"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_listEdges, throw_wrapped_listEdges, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_listEdges(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue MetaServiceAsyncProcessor::return_listEdges(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ListEdgesResp const& _return) { + ProtocolOut_ prot; + MetaService_listEdges_presult result; + result.get<0>().value = const_cast< ::nebula::meta::cpp2::ListEdgesResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("listEdges", &prot, protoSeqId, ctx, result); +} + +template +void MetaServiceAsyncProcessor::throw_wrapped_listEdges(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "listEdges"); + return; + } +} + +template +void MetaServiceAsyncProcessor::setUpAndProcess_listHosts(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &MetaServiceAsyncProcessor::process_listHosts, this); +} + +template +void MetaServiceAsyncProcessor::process_listHosts(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + MetaService_listHosts_pargs args; + ::nebula::meta::cpp2::ListHostsReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "MetaService.listHosts", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "listHosts"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_listHosts, throw_wrapped_listHosts, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_listHosts(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue MetaServiceAsyncProcessor::return_listHosts(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ListHostsResp const& _return) { + ProtocolOut_ prot; + MetaService_listHosts_presult result; + result.get<0>().value = const_cast< ::nebula::meta::cpp2::ListHostsResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("listHosts", &prot, protoSeqId, ctx, result); +} + +template +void MetaServiceAsyncProcessor::throw_wrapped_listHosts(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "listHosts"); + return; + } +} + +template +void MetaServiceAsyncProcessor::setUpAndProcess_getPartsAlloc(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &MetaServiceAsyncProcessor::process_getPartsAlloc, this); +} + +template +void MetaServiceAsyncProcessor::process_getPartsAlloc(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + MetaService_getPartsAlloc_pargs args; + ::nebula::meta::cpp2::GetPartsAllocReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "MetaService.getPartsAlloc", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "getPartsAlloc"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_getPartsAlloc, throw_wrapped_getPartsAlloc, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_getPartsAlloc(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue MetaServiceAsyncProcessor::return_getPartsAlloc(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::GetPartsAllocResp const& _return) { + ProtocolOut_ prot; + MetaService_getPartsAlloc_presult result; + result.get<0>().value = const_cast< ::nebula::meta::cpp2::GetPartsAllocResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("getPartsAlloc", &prot, protoSeqId, ctx, result); +} + +template +void MetaServiceAsyncProcessor::throw_wrapped_getPartsAlloc(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "getPartsAlloc"); + return; + } +} + +template +void MetaServiceAsyncProcessor::setUpAndProcess_listParts(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &MetaServiceAsyncProcessor::process_listParts, this); +} + +template +void MetaServiceAsyncProcessor::process_listParts(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + MetaService_listParts_pargs args; + ::nebula::meta::cpp2::ListPartsReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "MetaService.listParts", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "listParts"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_listParts, throw_wrapped_listParts, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_listParts(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue MetaServiceAsyncProcessor::return_listParts(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ListPartsResp const& _return) { + ProtocolOut_ prot; + MetaService_listParts_presult result; + result.get<0>().value = const_cast< ::nebula::meta::cpp2::ListPartsResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("listParts", &prot, protoSeqId, ctx, result); +} + +template +void MetaServiceAsyncProcessor::throw_wrapped_listParts(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "listParts"); + return; + } +} + +template +void MetaServiceAsyncProcessor::setUpAndProcess_multiPut(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &MetaServiceAsyncProcessor::process_multiPut, this); +} + +template +void MetaServiceAsyncProcessor::process_multiPut(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + MetaService_multiPut_pargs args; + ::nebula::meta::cpp2::MultiPutReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "MetaService.multiPut", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "multiPut"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_multiPut, throw_wrapped_multiPut, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_multiPut(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue MetaServiceAsyncProcessor::return_multiPut(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ExecResp const& _return) { + ProtocolOut_ prot; + MetaService_multiPut_presult result; + result.get<0>().value = const_cast< ::nebula::meta::cpp2::ExecResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("multiPut", &prot, protoSeqId, ctx, result); +} + +template +void MetaServiceAsyncProcessor::throw_wrapped_multiPut(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "multiPut"); + return; + } +} + +template +void MetaServiceAsyncProcessor::setUpAndProcess_get(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &MetaServiceAsyncProcessor::process_get, this); +} + +template +void MetaServiceAsyncProcessor::process_get(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + MetaService_get_pargs args; + ::nebula::meta::cpp2::GetReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "MetaService.get", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "get"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_get, throw_wrapped_get, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_get(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue MetaServiceAsyncProcessor::return_get(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::GetResp const& _return) { + ProtocolOut_ prot; + MetaService_get_presult result; + result.get<0>().value = const_cast< ::nebula::meta::cpp2::GetResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("get", &prot, protoSeqId, ctx, result); +} + +template +void MetaServiceAsyncProcessor::throw_wrapped_get(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "get"); + return; + } +} + +template +void MetaServiceAsyncProcessor::setUpAndProcess_multiGet(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &MetaServiceAsyncProcessor::process_multiGet, this); +} + +template +void MetaServiceAsyncProcessor::process_multiGet(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + MetaService_multiGet_pargs args; + ::nebula::meta::cpp2::MultiGetReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "MetaService.multiGet", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "multiGet"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_multiGet, throw_wrapped_multiGet, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_multiGet(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue MetaServiceAsyncProcessor::return_multiGet(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::MultiGetResp const& _return) { + ProtocolOut_ prot; + MetaService_multiGet_presult result; + result.get<0>().value = const_cast< ::nebula::meta::cpp2::MultiGetResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("multiGet", &prot, protoSeqId, ctx, result); +} + +template +void MetaServiceAsyncProcessor::throw_wrapped_multiGet(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "multiGet"); + return; + } +} + +template +void MetaServiceAsyncProcessor::setUpAndProcess_remove(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &MetaServiceAsyncProcessor::process_remove, this); +} + +template +void MetaServiceAsyncProcessor::process_remove(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + MetaService_remove_pargs args; + ::nebula::meta::cpp2::RemoveReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "MetaService.remove", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "remove"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_remove, throw_wrapped_remove, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_remove(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue MetaServiceAsyncProcessor::return_remove(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ExecResp const& _return) { + ProtocolOut_ prot; + MetaService_remove_presult result; + result.get<0>().value = const_cast< ::nebula::meta::cpp2::ExecResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("remove", &prot, protoSeqId, ctx, result); +} + +template +void MetaServiceAsyncProcessor::throw_wrapped_remove(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "remove"); + return; + } +} + +template +void MetaServiceAsyncProcessor::setUpAndProcess_removeRange(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &MetaServiceAsyncProcessor::process_removeRange, this); +} + +template +void MetaServiceAsyncProcessor::process_removeRange(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + MetaService_removeRange_pargs args; + ::nebula::meta::cpp2::RemoveRangeReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "MetaService.removeRange", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "removeRange"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_removeRange, throw_wrapped_removeRange, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_removeRange(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue MetaServiceAsyncProcessor::return_removeRange(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ExecResp const& _return) { + ProtocolOut_ prot; + MetaService_removeRange_presult result; + result.get<0>().value = const_cast< ::nebula::meta::cpp2::ExecResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("removeRange", &prot, protoSeqId, ctx, result); +} + +template +void MetaServiceAsyncProcessor::throw_wrapped_removeRange(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "removeRange"); + return; + } +} + +template +void MetaServiceAsyncProcessor::setUpAndProcess_scan(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &MetaServiceAsyncProcessor::process_scan, this); +} + +template +void MetaServiceAsyncProcessor::process_scan(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + MetaService_scan_pargs args; + ::nebula::meta::cpp2::ScanReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "MetaService.scan", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "scan"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_scan, throw_wrapped_scan, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_scan(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue MetaServiceAsyncProcessor::return_scan(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ScanResp const& _return) { + ProtocolOut_ prot; + MetaService_scan_presult result; + result.get<0>().value = const_cast< ::nebula::meta::cpp2::ScanResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("scan", &prot, protoSeqId, ctx, result); +} + +template +void MetaServiceAsyncProcessor::throw_wrapped_scan(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "scan"); + return; + } +} + +template +void MetaServiceAsyncProcessor::setUpAndProcess_createTagIndex(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &MetaServiceAsyncProcessor::process_createTagIndex, this); +} + +template +void MetaServiceAsyncProcessor::process_createTagIndex(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + MetaService_createTagIndex_pargs args; + ::nebula::meta::cpp2::CreateTagIndexReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "MetaService.createTagIndex", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "createTagIndex"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_createTagIndex, throw_wrapped_createTagIndex, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_createTagIndex(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue MetaServiceAsyncProcessor::return_createTagIndex(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ExecResp const& _return) { + ProtocolOut_ prot; + MetaService_createTagIndex_presult result; + result.get<0>().value = const_cast< ::nebula::meta::cpp2::ExecResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("createTagIndex", &prot, protoSeqId, ctx, result); +} + +template +void MetaServiceAsyncProcessor::throw_wrapped_createTagIndex(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "createTagIndex"); + return; + } +} + +template +void MetaServiceAsyncProcessor::setUpAndProcess_dropTagIndex(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &MetaServiceAsyncProcessor::process_dropTagIndex, this); +} + +template +void MetaServiceAsyncProcessor::process_dropTagIndex(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + MetaService_dropTagIndex_pargs args; + ::nebula::meta::cpp2::DropTagIndexReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "MetaService.dropTagIndex", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "dropTagIndex"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_dropTagIndex, throw_wrapped_dropTagIndex, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_dropTagIndex(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue MetaServiceAsyncProcessor::return_dropTagIndex(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ExecResp const& _return) { + ProtocolOut_ prot; + MetaService_dropTagIndex_presult result; + result.get<0>().value = const_cast< ::nebula::meta::cpp2::ExecResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("dropTagIndex", &prot, protoSeqId, ctx, result); +} + +template +void MetaServiceAsyncProcessor::throw_wrapped_dropTagIndex(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "dropTagIndex"); + return; + } +} + +template +void MetaServiceAsyncProcessor::setUpAndProcess_getTagIndex(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &MetaServiceAsyncProcessor::process_getTagIndex, this); +} + +template +void MetaServiceAsyncProcessor::process_getTagIndex(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + MetaService_getTagIndex_pargs args; + ::nebula::meta::cpp2::GetTagIndexReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "MetaService.getTagIndex", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "getTagIndex"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_getTagIndex, throw_wrapped_getTagIndex, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_getTagIndex(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue MetaServiceAsyncProcessor::return_getTagIndex(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::GetTagIndexResp const& _return) { + ProtocolOut_ prot; + MetaService_getTagIndex_presult result; + result.get<0>().value = const_cast< ::nebula::meta::cpp2::GetTagIndexResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("getTagIndex", &prot, protoSeqId, ctx, result); +} + +template +void MetaServiceAsyncProcessor::throw_wrapped_getTagIndex(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "getTagIndex"); + return; + } +} + +template +void MetaServiceAsyncProcessor::setUpAndProcess_listTagIndexes(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &MetaServiceAsyncProcessor::process_listTagIndexes, this); +} + +template +void MetaServiceAsyncProcessor::process_listTagIndexes(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + MetaService_listTagIndexes_pargs args; + ::nebula::meta::cpp2::ListTagIndexesReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "MetaService.listTagIndexes", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "listTagIndexes"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_listTagIndexes, throw_wrapped_listTagIndexes, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_listTagIndexes(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue MetaServiceAsyncProcessor::return_listTagIndexes(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ListTagIndexesResp const& _return) { + ProtocolOut_ prot; + MetaService_listTagIndexes_presult result; + result.get<0>().value = const_cast< ::nebula::meta::cpp2::ListTagIndexesResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("listTagIndexes", &prot, protoSeqId, ctx, result); +} + +template +void MetaServiceAsyncProcessor::throw_wrapped_listTagIndexes(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "listTagIndexes"); + return; + } +} + +template +void MetaServiceAsyncProcessor::setUpAndProcess_rebuildTagIndex(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &MetaServiceAsyncProcessor::process_rebuildTagIndex, this); +} + +template +void MetaServiceAsyncProcessor::process_rebuildTagIndex(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + MetaService_rebuildTagIndex_pargs args; + ::nebula::meta::cpp2::RebuildIndexReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "MetaService.rebuildTagIndex", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "rebuildTagIndex"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_rebuildTagIndex, throw_wrapped_rebuildTagIndex, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_rebuildTagIndex(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue MetaServiceAsyncProcessor::return_rebuildTagIndex(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ExecResp const& _return) { + ProtocolOut_ prot; + MetaService_rebuildTagIndex_presult result; + result.get<0>().value = const_cast< ::nebula::meta::cpp2::ExecResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("rebuildTagIndex", &prot, protoSeqId, ctx, result); +} + +template +void MetaServiceAsyncProcessor::throw_wrapped_rebuildTagIndex(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "rebuildTagIndex"); + return; + } +} + +template +void MetaServiceAsyncProcessor::setUpAndProcess_listTagIndexStatus(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &MetaServiceAsyncProcessor::process_listTagIndexStatus, this); +} + +template +void MetaServiceAsyncProcessor::process_listTagIndexStatus(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + MetaService_listTagIndexStatus_pargs args; + ::nebula::meta::cpp2::ListIndexStatusReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "MetaService.listTagIndexStatus", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "listTagIndexStatus"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_listTagIndexStatus, throw_wrapped_listTagIndexStatus, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_listTagIndexStatus(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue MetaServiceAsyncProcessor::return_listTagIndexStatus(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ListIndexStatusResp const& _return) { + ProtocolOut_ prot; + MetaService_listTagIndexStatus_presult result; + result.get<0>().value = const_cast< ::nebula::meta::cpp2::ListIndexStatusResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("listTagIndexStatus", &prot, protoSeqId, ctx, result); +} + +template +void MetaServiceAsyncProcessor::throw_wrapped_listTagIndexStatus(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "listTagIndexStatus"); + return; + } +} + +template +void MetaServiceAsyncProcessor::setUpAndProcess_createEdgeIndex(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &MetaServiceAsyncProcessor::process_createEdgeIndex, this); +} + +template +void MetaServiceAsyncProcessor::process_createEdgeIndex(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + MetaService_createEdgeIndex_pargs args; + ::nebula::meta::cpp2::CreateEdgeIndexReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "MetaService.createEdgeIndex", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "createEdgeIndex"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_createEdgeIndex, throw_wrapped_createEdgeIndex, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_createEdgeIndex(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue MetaServiceAsyncProcessor::return_createEdgeIndex(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ExecResp const& _return) { + ProtocolOut_ prot; + MetaService_createEdgeIndex_presult result; + result.get<0>().value = const_cast< ::nebula::meta::cpp2::ExecResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("createEdgeIndex", &prot, protoSeqId, ctx, result); +} + +template +void MetaServiceAsyncProcessor::throw_wrapped_createEdgeIndex(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "createEdgeIndex"); + return; + } +} + +template +void MetaServiceAsyncProcessor::setUpAndProcess_dropEdgeIndex(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &MetaServiceAsyncProcessor::process_dropEdgeIndex, this); +} + +template +void MetaServiceAsyncProcessor::process_dropEdgeIndex(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + MetaService_dropEdgeIndex_pargs args; + ::nebula::meta::cpp2::DropEdgeIndexReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "MetaService.dropEdgeIndex", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "dropEdgeIndex"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_dropEdgeIndex, throw_wrapped_dropEdgeIndex, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_dropEdgeIndex(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue MetaServiceAsyncProcessor::return_dropEdgeIndex(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ExecResp const& _return) { + ProtocolOut_ prot; + MetaService_dropEdgeIndex_presult result; + result.get<0>().value = const_cast< ::nebula::meta::cpp2::ExecResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("dropEdgeIndex", &prot, protoSeqId, ctx, result); +} + +template +void MetaServiceAsyncProcessor::throw_wrapped_dropEdgeIndex(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "dropEdgeIndex"); + return; + } +} + +template +void MetaServiceAsyncProcessor::setUpAndProcess_getEdgeIndex(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &MetaServiceAsyncProcessor::process_getEdgeIndex, this); +} + +template +void MetaServiceAsyncProcessor::process_getEdgeIndex(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + MetaService_getEdgeIndex_pargs args; + ::nebula::meta::cpp2::GetEdgeIndexReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "MetaService.getEdgeIndex", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "getEdgeIndex"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_getEdgeIndex, throw_wrapped_getEdgeIndex, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_getEdgeIndex(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue MetaServiceAsyncProcessor::return_getEdgeIndex(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::GetEdgeIndexResp const& _return) { + ProtocolOut_ prot; + MetaService_getEdgeIndex_presult result; + result.get<0>().value = const_cast< ::nebula::meta::cpp2::GetEdgeIndexResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("getEdgeIndex", &prot, protoSeqId, ctx, result); +} + +template +void MetaServiceAsyncProcessor::throw_wrapped_getEdgeIndex(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "getEdgeIndex"); + return; + } +} + +template +void MetaServiceAsyncProcessor::setUpAndProcess_listEdgeIndexes(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &MetaServiceAsyncProcessor::process_listEdgeIndexes, this); +} + +template +void MetaServiceAsyncProcessor::process_listEdgeIndexes(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + MetaService_listEdgeIndexes_pargs args; + ::nebula::meta::cpp2::ListEdgeIndexesReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "MetaService.listEdgeIndexes", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "listEdgeIndexes"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_listEdgeIndexes, throw_wrapped_listEdgeIndexes, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_listEdgeIndexes(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue MetaServiceAsyncProcessor::return_listEdgeIndexes(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ListEdgeIndexesResp const& _return) { + ProtocolOut_ prot; + MetaService_listEdgeIndexes_presult result; + result.get<0>().value = const_cast< ::nebula::meta::cpp2::ListEdgeIndexesResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("listEdgeIndexes", &prot, protoSeqId, ctx, result); +} + +template +void MetaServiceAsyncProcessor::throw_wrapped_listEdgeIndexes(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "listEdgeIndexes"); + return; + } +} + +template +void MetaServiceAsyncProcessor::setUpAndProcess_rebuildEdgeIndex(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &MetaServiceAsyncProcessor::process_rebuildEdgeIndex, this); +} + +template +void MetaServiceAsyncProcessor::process_rebuildEdgeIndex(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + MetaService_rebuildEdgeIndex_pargs args; + ::nebula::meta::cpp2::RebuildIndexReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "MetaService.rebuildEdgeIndex", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "rebuildEdgeIndex"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_rebuildEdgeIndex, throw_wrapped_rebuildEdgeIndex, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_rebuildEdgeIndex(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue MetaServiceAsyncProcessor::return_rebuildEdgeIndex(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ExecResp const& _return) { + ProtocolOut_ prot; + MetaService_rebuildEdgeIndex_presult result; + result.get<0>().value = const_cast< ::nebula::meta::cpp2::ExecResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("rebuildEdgeIndex", &prot, protoSeqId, ctx, result); +} + +template +void MetaServiceAsyncProcessor::throw_wrapped_rebuildEdgeIndex(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "rebuildEdgeIndex"); + return; + } +} + +template +void MetaServiceAsyncProcessor::setUpAndProcess_listEdgeIndexStatus(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &MetaServiceAsyncProcessor::process_listEdgeIndexStatus, this); +} + +template +void MetaServiceAsyncProcessor::process_listEdgeIndexStatus(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + MetaService_listEdgeIndexStatus_pargs args; + ::nebula::meta::cpp2::ListIndexStatusReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "MetaService.listEdgeIndexStatus", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "listEdgeIndexStatus"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_listEdgeIndexStatus, throw_wrapped_listEdgeIndexStatus, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_listEdgeIndexStatus(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue MetaServiceAsyncProcessor::return_listEdgeIndexStatus(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ListIndexStatusResp const& _return) { + ProtocolOut_ prot; + MetaService_listEdgeIndexStatus_presult result; + result.get<0>().value = const_cast< ::nebula::meta::cpp2::ListIndexStatusResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("listEdgeIndexStatus", &prot, protoSeqId, ctx, result); +} + +template +void MetaServiceAsyncProcessor::throw_wrapped_listEdgeIndexStatus(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "listEdgeIndexStatus"); + return; + } +} + +template +void MetaServiceAsyncProcessor::setUpAndProcess_createUser(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &MetaServiceAsyncProcessor::process_createUser, this); +} + +template +void MetaServiceAsyncProcessor::process_createUser(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + MetaService_createUser_pargs args; + ::nebula::meta::cpp2::CreateUserReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "MetaService.createUser", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "createUser"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_createUser, throw_wrapped_createUser, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_createUser(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue MetaServiceAsyncProcessor::return_createUser(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ExecResp const& _return) { + ProtocolOut_ prot; + MetaService_createUser_presult result; + result.get<0>().value = const_cast< ::nebula::meta::cpp2::ExecResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("createUser", &prot, protoSeqId, ctx, result); +} + +template +void MetaServiceAsyncProcessor::throw_wrapped_createUser(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "createUser"); + return; + } +} + +template +void MetaServiceAsyncProcessor::setUpAndProcess_dropUser(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &MetaServiceAsyncProcessor::process_dropUser, this); +} + +template +void MetaServiceAsyncProcessor::process_dropUser(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + MetaService_dropUser_pargs args; + ::nebula::meta::cpp2::DropUserReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "MetaService.dropUser", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "dropUser"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_dropUser, throw_wrapped_dropUser, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_dropUser(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue MetaServiceAsyncProcessor::return_dropUser(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ExecResp const& _return) { + ProtocolOut_ prot; + MetaService_dropUser_presult result; + result.get<0>().value = const_cast< ::nebula::meta::cpp2::ExecResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("dropUser", &prot, protoSeqId, ctx, result); +} + +template +void MetaServiceAsyncProcessor::throw_wrapped_dropUser(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "dropUser"); + return; + } +} + +template +void MetaServiceAsyncProcessor::setUpAndProcess_alterUser(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &MetaServiceAsyncProcessor::process_alterUser, this); +} + +template +void MetaServiceAsyncProcessor::process_alterUser(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + MetaService_alterUser_pargs args; + ::nebula::meta::cpp2::AlterUserReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "MetaService.alterUser", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "alterUser"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_alterUser, throw_wrapped_alterUser, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_alterUser(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue MetaServiceAsyncProcessor::return_alterUser(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ExecResp const& _return) { + ProtocolOut_ prot; + MetaService_alterUser_presult result; + result.get<0>().value = const_cast< ::nebula::meta::cpp2::ExecResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("alterUser", &prot, protoSeqId, ctx, result); +} + +template +void MetaServiceAsyncProcessor::throw_wrapped_alterUser(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "alterUser"); + return; + } +} + +template +void MetaServiceAsyncProcessor::setUpAndProcess_grantRole(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &MetaServiceAsyncProcessor::process_grantRole, this); +} + +template +void MetaServiceAsyncProcessor::process_grantRole(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + MetaService_grantRole_pargs args; + ::nebula::meta::cpp2::GrantRoleReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "MetaService.grantRole", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "grantRole"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_grantRole, throw_wrapped_grantRole, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_grantRole(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue MetaServiceAsyncProcessor::return_grantRole(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ExecResp const& _return) { + ProtocolOut_ prot; + MetaService_grantRole_presult result; + result.get<0>().value = const_cast< ::nebula::meta::cpp2::ExecResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("grantRole", &prot, protoSeqId, ctx, result); +} + +template +void MetaServiceAsyncProcessor::throw_wrapped_grantRole(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "grantRole"); + return; + } +} + +template +void MetaServiceAsyncProcessor::setUpAndProcess_revokeRole(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &MetaServiceAsyncProcessor::process_revokeRole, this); +} + +template +void MetaServiceAsyncProcessor::process_revokeRole(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + MetaService_revokeRole_pargs args; + ::nebula::meta::cpp2::RevokeRoleReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "MetaService.revokeRole", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "revokeRole"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_revokeRole, throw_wrapped_revokeRole, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_revokeRole(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue MetaServiceAsyncProcessor::return_revokeRole(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ExecResp const& _return) { + ProtocolOut_ prot; + MetaService_revokeRole_presult result; + result.get<0>().value = const_cast< ::nebula::meta::cpp2::ExecResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("revokeRole", &prot, protoSeqId, ctx, result); +} + +template +void MetaServiceAsyncProcessor::throw_wrapped_revokeRole(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "revokeRole"); + return; + } +} + +template +void MetaServiceAsyncProcessor::setUpAndProcess_listUsers(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &MetaServiceAsyncProcessor::process_listUsers, this); +} + +template +void MetaServiceAsyncProcessor::process_listUsers(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + MetaService_listUsers_pargs args; + ::nebula::meta::cpp2::ListUsersReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "MetaService.listUsers", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "listUsers"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_listUsers, throw_wrapped_listUsers, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_listUsers(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue MetaServiceAsyncProcessor::return_listUsers(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ListUsersResp const& _return) { + ProtocolOut_ prot; + MetaService_listUsers_presult result; + result.get<0>().value = const_cast< ::nebula::meta::cpp2::ListUsersResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("listUsers", &prot, protoSeqId, ctx, result); +} + +template +void MetaServiceAsyncProcessor::throw_wrapped_listUsers(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "listUsers"); + return; + } +} + +template +void MetaServiceAsyncProcessor::setUpAndProcess_listRoles(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &MetaServiceAsyncProcessor::process_listRoles, this); +} + +template +void MetaServiceAsyncProcessor::process_listRoles(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + MetaService_listRoles_pargs args; + ::nebula::meta::cpp2::ListRolesReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "MetaService.listRoles", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "listRoles"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_listRoles, throw_wrapped_listRoles, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_listRoles(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue MetaServiceAsyncProcessor::return_listRoles(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ListRolesResp const& _return) { + ProtocolOut_ prot; + MetaService_listRoles_presult result; + result.get<0>().value = const_cast< ::nebula::meta::cpp2::ListRolesResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("listRoles", &prot, protoSeqId, ctx, result); +} + +template +void MetaServiceAsyncProcessor::throw_wrapped_listRoles(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "listRoles"); + return; + } +} + +template +void MetaServiceAsyncProcessor::setUpAndProcess_getUserRoles(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &MetaServiceAsyncProcessor::process_getUserRoles, this); +} + +template +void MetaServiceAsyncProcessor::process_getUserRoles(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + MetaService_getUserRoles_pargs args; + ::nebula::meta::cpp2::GetUserRolesReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "MetaService.getUserRoles", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "getUserRoles"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_getUserRoles, throw_wrapped_getUserRoles, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_getUserRoles(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue MetaServiceAsyncProcessor::return_getUserRoles(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ListRolesResp const& _return) { + ProtocolOut_ prot; + MetaService_getUserRoles_presult result; + result.get<0>().value = const_cast< ::nebula::meta::cpp2::ListRolesResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("getUserRoles", &prot, protoSeqId, ctx, result); +} + +template +void MetaServiceAsyncProcessor::throw_wrapped_getUserRoles(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "getUserRoles"); + return; + } +} + +template +void MetaServiceAsyncProcessor::setUpAndProcess_changePassword(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &MetaServiceAsyncProcessor::process_changePassword, this); +} + +template +void MetaServiceAsyncProcessor::process_changePassword(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + MetaService_changePassword_pargs args; + ::nebula::meta::cpp2::ChangePasswordReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "MetaService.changePassword", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "changePassword"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_changePassword, throw_wrapped_changePassword, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_changePassword(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue MetaServiceAsyncProcessor::return_changePassword(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ExecResp const& _return) { + ProtocolOut_ prot; + MetaService_changePassword_presult result; + result.get<0>().value = const_cast< ::nebula::meta::cpp2::ExecResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("changePassword", &prot, protoSeqId, ctx, result); +} + +template +void MetaServiceAsyncProcessor::throw_wrapped_changePassword(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "changePassword"); + return; + } +} + +template +void MetaServiceAsyncProcessor::setUpAndProcess_heartBeat(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &MetaServiceAsyncProcessor::process_heartBeat, this); +} + +template +void MetaServiceAsyncProcessor::process_heartBeat(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + MetaService_heartBeat_pargs args; + ::nebula::meta::cpp2::HBReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "MetaService.heartBeat", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "heartBeat"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_heartBeat, throw_wrapped_heartBeat, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_heartBeat(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue MetaServiceAsyncProcessor::return_heartBeat(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::HBResp const& _return) { + ProtocolOut_ prot; + MetaService_heartBeat_presult result; + result.get<0>().value = const_cast< ::nebula::meta::cpp2::HBResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("heartBeat", &prot, protoSeqId, ctx, result); +} + +template +void MetaServiceAsyncProcessor::throw_wrapped_heartBeat(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "heartBeat"); + return; + } +} + +template +void MetaServiceAsyncProcessor::setUpAndProcess_balance(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &MetaServiceAsyncProcessor::process_balance, this); +} + +template +void MetaServiceAsyncProcessor::process_balance(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + MetaService_balance_pargs args; + ::nebula::meta::cpp2::BalanceReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "MetaService.balance", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "balance"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_balance, throw_wrapped_balance, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_balance(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue MetaServiceAsyncProcessor::return_balance(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::BalanceResp const& _return) { + ProtocolOut_ prot; + MetaService_balance_presult result; + result.get<0>().value = const_cast< ::nebula::meta::cpp2::BalanceResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("balance", &prot, protoSeqId, ctx, result); +} + +template +void MetaServiceAsyncProcessor::throw_wrapped_balance(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "balance"); + return; + } +} + +template +void MetaServiceAsyncProcessor::setUpAndProcess_leaderBalance(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &MetaServiceAsyncProcessor::process_leaderBalance, this); +} + +template +void MetaServiceAsyncProcessor::process_leaderBalance(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + MetaService_leaderBalance_pargs args; + ::nebula::meta::cpp2::LeaderBalanceReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "MetaService.leaderBalance", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "leaderBalance"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_leaderBalance, throw_wrapped_leaderBalance, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_leaderBalance(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue MetaServiceAsyncProcessor::return_leaderBalance(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ExecResp const& _return) { + ProtocolOut_ prot; + MetaService_leaderBalance_presult result; + result.get<0>().value = const_cast< ::nebula::meta::cpp2::ExecResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("leaderBalance", &prot, protoSeqId, ctx, result); +} + +template +void MetaServiceAsyncProcessor::throw_wrapped_leaderBalance(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "leaderBalance"); + return; + } +} + +template +void MetaServiceAsyncProcessor::setUpAndProcess_regConfig(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &MetaServiceAsyncProcessor::process_regConfig, this); +} + +template +void MetaServiceAsyncProcessor::process_regConfig(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + MetaService_regConfig_pargs args; + ::nebula::meta::cpp2::RegConfigReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "MetaService.regConfig", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "regConfig"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_regConfig, throw_wrapped_regConfig, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_regConfig(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue MetaServiceAsyncProcessor::return_regConfig(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ExecResp const& _return) { + ProtocolOut_ prot; + MetaService_regConfig_presult result; + result.get<0>().value = const_cast< ::nebula::meta::cpp2::ExecResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("regConfig", &prot, protoSeqId, ctx, result); +} + +template +void MetaServiceAsyncProcessor::throw_wrapped_regConfig(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "regConfig"); + return; + } +} + +template +void MetaServiceAsyncProcessor::setUpAndProcess_getConfig(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &MetaServiceAsyncProcessor::process_getConfig, this); +} + +template +void MetaServiceAsyncProcessor::process_getConfig(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + MetaService_getConfig_pargs args; + ::nebula::meta::cpp2::GetConfigReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "MetaService.getConfig", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "getConfig"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_getConfig, throw_wrapped_getConfig, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_getConfig(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue MetaServiceAsyncProcessor::return_getConfig(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::GetConfigResp const& _return) { + ProtocolOut_ prot; + MetaService_getConfig_presult result; + result.get<0>().value = const_cast< ::nebula::meta::cpp2::GetConfigResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("getConfig", &prot, protoSeqId, ctx, result); +} + +template +void MetaServiceAsyncProcessor::throw_wrapped_getConfig(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "getConfig"); + return; + } +} + +template +void MetaServiceAsyncProcessor::setUpAndProcess_setConfig(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &MetaServiceAsyncProcessor::process_setConfig, this); +} + +template +void MetaServiceAsyncProcessor::process_setConfig(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + MetaService_setConfig_pargs args; + ::nebula::meta::cpp2::SetConfigReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "MetaService.setConfig", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "setConfig"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_setConfig, throw_wrapped_setConfig, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_setConfig(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue MetaServiceAsyncProcessor::return_setConfig(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ExecResp const& _return) { + ProtocolOut_ prot; + MetaService_setConfig_presult result; + result.get<0>().value = const_cast< ::nebula::meta::cpp2::ExecResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("setConfig", &prot, protoSeqId, ctx, result); +} + +template +void MetaServiceAsyncProcessor::throw_wrapped_setConfig(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "setConfig"); + return; + } +} + +template +void MetaServiceAsyncProcessor::setUpAndProcess_listConfigs(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &MetaServiceAsyncProcessor::process_listConfigs, this); +} + +template +void MetaServiceAsyncProcessor::process_listConfigs(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + MetaService_listConfigs_pargs args; + ::nebula::meta::cpp2::ListConfigsReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "MetaService.listConfigs", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "listConfigs"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_listConfigs, throw_wrapped_listConfigs, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_listConfigs(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue MetaServiceAsyncProcessor::return_listConfigs(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ListConfigsResp const& _return) { + ProtocolOut_ prot; + MetaService_listConfigs_presult result; + result.get<0>().value = const_cast< ::nebula::meta::cpp2::ListConfigsResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("listConfigs", &prot, protoSeqId, ctx, result); +} + +template +void MetaServiceAsyncProcessor::throw_wrapped_listConfigs(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "listConfigs"); + return; + } +} + +template +void MetaServiceAsyncProcessor::setUpAndProcess_createSnapshot(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &MetaServiceAsyncProcessor::process_createSnapshot, this); +} + +template +void MetaServiceAsyncProcessor::process_createSnapshot(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + MetaService_createSnapshot_pargs args; + ::nebula::meta::cpp2::CreateSnapshotReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "MetaService.createSnapshot", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "createSnapshot"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_createSnapshot, throw_wrapped_createSnapshot, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_createSnapshot(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue MetaServiceAsyncProcessor::return_createSnapshot(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ExecResp const& _return) { + ProtocolOut_ prot; + MetaService_createSnapshot_presult result; + result.get<0>().value = const_cast< ::nebula::meta::cpp2::ExecResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("createSnapshot", &prot, protoSeqId, ctx, result); +} + +template +void MetaServiceAsyncProcessor::throw_wrapped_createSnapshot(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "createSnapshot"); + return; + } +} + +template +void MetaServiceAsyncProcessor::setUpAndProcess_dropSnapshot(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &MetaServiceAsyncProcessor::process_dropSnapshot, this); +} + +template +void MetaServiceAsyncProcessor::process_dropSnapshot(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + MetaService_dropSnapshot_pargs args; + ::nebula::meta::cpp2::DropSnapshotReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "MetaService.dropSnapshot", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "dropSnapshot"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_dropSnapshot, throw_wrapped_dropSnapshot, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_dropSnapshot(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue MetaServiceAsyncProcessor::return_dropSnapshot(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ExecResp const& _return) { + ProtocolOut_ prot; + MetaService_dropSnapshot_presult result; + result.get<0>().value = const_cast< ::nebula::meta::cpp2::ExecResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("dropSnapshot", &prot, protoSeqId, ctx, result); +} + +template +void MetaServiceAsyncProcessor::throw_wrapped_dropSnapshot(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "dropSnapshot"); + return; + } +} + +template +void MetaServiceAsyncProcessor::setUpAndProcess_listSnapshots(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &MetaServiceAsyncProcessor::process_listSnapshots, this); +} + +template +void MetaServiceAsyncProcessor::process_listSnapshots(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + MetaService_listSnapshots_pargs args; + ::nebula::meta::cpp2::ListSnapshotsReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "MetaService.listSnapshots", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "listSnapshots"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_listSnapshots, throw_wrapped_listSnapshots, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_listSnapshots(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue MetaServiceAsyncProcessor::return_listSnapshots(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ListSnapshotsResp const& _return) { + ProtocolOut_ prot; + MetaService_listSnapshots_presult result; + result.get<0>().value = const_cast< ::nebula::meta::cpp2::ListSnapshotsResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("listSnapshots", &prot, protoSeqId, ctx, result); +} + +template +void MetaServiceAsyncProcessor::throw_wrapped_listSnapshots(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "listSnapshots"); + return; + } +} + +template +void MetaServiceAsyncProcessor::setUpAndProcess_runAdminJob(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &MetaServiceAsyncProcessor::process_runAdminJob, this); +} + +template +void MetaServiceAsyncProcessor::process_runAdminJob(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + MetaService_runAdminJob_pargs args; + ::nebula::meta::cpp2::AdminJobReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "MetaService.runAdminJob", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "runAdminJob"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_runAdminJob, throw_wrapped_runAdminJob, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_runAdminJob(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue MetaServiceAsyncProcessor::return_runAdminJob(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::AdminJobResp const& _return) { + ProtocolOut_ prot; + MetaService_runAdminJob_presult result; + result.get<0>().value = const_cast< ::nebula::meta::cpp2::AdminJobResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("runAdminJob", &prot, protoSeqId, ctx, result); +} + +template +void MetaServiceAsyncProcessor::throw_wrapped_runAdminJob(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "runAdminJob"); + return; + } +} + +template +void MetaServiceAsyncProcessor::setUpAndProcess_addZone(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &MetaServiceAsyncProcessor::process_addZone, this); +} + +template +void MetaServiceAsyncProcessor::process_addZone(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + MetaService_addZone_pargs args; + ::nebula::meta::cpp2::AddZoneReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "MetaService.addZone", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "addZone"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_addZone, throw_wrapped_addZone, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_addZone(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue MetaServiceAsyncProcessor::return_addZone(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ExecResp const& _return) { + ProtocolOut_ prot; + MetaService_addZone_presult result; + result.get<0>().value = const_cast< ::nebula::meta::cpp2::ExecResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("addZone", &prot, protoSeqId, ctx, result); +} + +template +void MetaServiceAsyncProcessor::throw_wrapped_addZone(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "addZone"); + return; + } +} + +template +void MetaServiceAsyncProcessor::setUpAndProcess_dropZone(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &MetaServiceAsyncProcessor::process_dropZone, this); +} + +template +void MetaServiceAsyncProcessor::process_dropZone(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + MetaService_dropZone_pargs args; + ::nebula::meta::cpp2::DropZoneReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "MetaService.dropZone", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "dropZone"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_dropZone, throw_wrapped_dropZone, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_dropZone(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue MetaServiceAsyncProcessor::return_dropZone(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ExecResp const& _return) { + ProtocolOut_ prot; + MetaService_dropZone_presult result; + result.get<0>().value = const_cast< ::nebula::meta::cpp2::ExecResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("dropZone", &prot, protoSeqId, ctx, result); +} + +template +void MetaServiceAsyncProcessor::throw_wrapped_dropZone(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "dropZone"); + return; + } +} + +template +void MetaServiceAsyncProcessor::setUpAndProcess_addHostIntoZone(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &MetaServiceAsyncProcessor::process_addHostIntoZone, this); +} + +template +void MetaServiceAsyncProcessor::process_addHostIntoZone(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + MetaService_addHostIntoZone_pargs args; + ::nebula::meta::cpp2::AddHostIntoZoneReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "MetaService.addHostIntoZone", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "addHostIntoZone"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_addHostIntoZone, throw_wrapped_addHostIntoZone, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_addHostIntoZone(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue MetaServiceAsyncProcessor::return_addHostIntoZone(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ExecResp const& _return) { + ProtocolOut_ prot; + MetaService_addHostIntoZone_presult result; + result.get<0>().value = const_cast< ::nebula::meta::cpp2::ExecResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("addHostIntoZone", &prot, protoSeqId, ctx, result); +} + +template +void MetaServiceAsyncProcessor::throw_wrapped_addHostIntoZone(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "addHostIntoZone"); + return; + } +} + +template +void MetaServiceAsyncProcessor::setUpAndProcess_dropHostFromZone(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &MetaServiceAsyncProcessor::process_dropHostFromZone, this); +} + +template +void MetaServiceAsyncProcessor::process_dropHostFromZone(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + MetaService_dropHostFromZone_pargs args; + ::nebula::meta::cpp2::DropHostFromZoneReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "MetaService.dropHostFromZone", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "dropHostFromZone"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_dropHostFromZone, throw_wrapped_dropHostFromZone, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_dropHostFromZone(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue MetaServiceAsyncProcessor::return_dropHostFromZone(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ExecResp const& _return) { + ProtocolOut_ prot; + MetaService_dropHostFromZone_presult result; + result.get<0>().value = const_cast< ::nebula::meta::cpp2::ExecResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("dropHostFromZone", &prot, protoSeqId, ctx, result); +} + +template +void MetaServiceAsyncProcessor::throw_wrapped_dropHostFromZone(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "dropHostFromZone"); + return; + } +} + +template +void MetaServiceAsyncProcessor::setUpAndProcess_getZone(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &MetaServiceAsyncProcessor::process_getZone, this); +} + +template +void MetaServiceAsyncProcessor::process_getZone(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + MetaService_getZone_pargs args; + ::nebula::meta::cpp2::GetZoneReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "MetaService.getZone", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "getZone"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_getZone, throw_wrapped_getZone, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_getZone(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue MetaServiceAsyncProcessor::return_getZone(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::GetZoneResp const& _return) { + ProtocolOut_ prot; + MetaService_getZone_presult result; + result.get<0>().value = const_cast< ::nebula::meta::cpp2::GetZoneResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("getZone", &prot, protoSeqId, ctx, result); +} + +template +void MetaServiceAsyncProcessor::throw_wrapped_getZone(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "getZone"); + return; + } +} + +template +void MetaServiceAsyncProcessor::setUpAndProcess_listZones(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &MetaServiceAsyncProcessor::process_listZones, this); +} + +template +void MetaServiceAsyncProcessor::process_listZones(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + MetaService_listZones_pargs args; + ::nebula::meta::cpp2::ListZonesReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "MetaService.listZones", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "listZones"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_listZones, throw_wrapped_listZones, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_listZones(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue MetaServiceAsyncProcessor::return_listZones(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ListZonesResp const& _return) { + ProtocolOut_ prot; + MetaService_listZones_presult result; + result.get<0>().value = const_cast< ::nebula::meta::cpp2::ListZonesResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("listZones", &prot, protoSeqId, ctx, result); +} + +template +void MetaServiceAsyncProcessor::throw_wrapped_listZones(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "listZones"); + return; + } +} + +template +void MetaServiceAsyncProcessor::setUpAndProcess_addGroup(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &MetaServiceAsyncProcessor::process_addGroup, this); +} + +template +void MetaServiceAsyncProcessor::process_addGroup(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + MetaService_addGroup_pargs args; + ::nebula::meta::cpp2::AddGroupReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "MetaService.addGroup", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "addGroup"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_addGroup, throw_wrapped_addGroup, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_addGroup(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue MetaServiceAsyncProcessor::return_addGroup(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ExecResp const& _return) { + ProtocolOut_ prot; + MetaService_addGroup_presult result; + result.get<0>().value = const_cast< ::nebula::meta::cpp2::ExecResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("addGroup", &prot, protoSeqId, ctx, result); +} + +template +void MetaServiceAsyncProcessor::throw_wrapped_addGroup(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "addGroup"); + return; + } +} + +template +void MetaServiceAsyncProcessor::setUpAndProcess_dropGroup(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &MetaServiceAsyncProcessor::process_dropGroup, this); +} + +template +void MetaServiceAsyncProcessor::process_dropGroup(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + MetaService_dropGroup_pargs args; + ::nebula::meta::cpp2::DropGroupReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "MetaService.dropGroup", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "dropGroup"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_dropGroup, throw_wrapped_dropGroup, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_dropGroup(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue MetaServiceAsyncProcessor::return_dropGroup(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ExecResp const& _return) { + ProtocolOut_ prot; + MetaService_dropGroup_presult result; + result.get<0>().value = const_cast< ::nebula::meta::cpp2::ExecResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("dropGroup", &prot, protoSeqId, ctx, result); +} + +template +void MetaServiceAsyncProcessor::throw_wrapped_dropGroup(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "dropGroup"); + return; + } +} + +template +void MetaServiceAsyncProcessor::setUpAndProcess_addZoneIntoGroup(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &MetaServiceAsyncProcessor::process_addZoneIntoGroup, this); +} + +template +void MetaServiceAsyncProcessor::process_addZoneIntoGroup(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + MetaService_addZoneIntoGroup_pargs args; + ::nebula::meta::cpp2::AddZoneIntoGroupReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "MetaService.addZoneIntoGroup", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "addZoneIntoGroup"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_addZoneIntoGroup, throw_wrapped_addZoneIntoGroup, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_addZoneIntoGroup(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue MetaServiceAsyncProcessor::return_addZoneIntoGroup(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ExecResp const& _return) { + ProtocolOut_ prot; + MetaService_addZoneIntoGroup_presult result; + result.get<0>().value = const_cast< ::nebula::meta::cpp2::ExecResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("addZoneIntoGroup", &prot, protoSeqId, ctx, result); +} + +template +void MetaServiceAsyncProcessor::throw_wrapped_addZoneIntoGroup(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "addZoneIntoGroup"); + return; + } +} + +template +void MetaServiceAsyncProcessor::setUpAndProcess_dropZoneFromGroup(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &MetaServiceAsyncProcessor::process_dropZoneFromGroup, this); +} + +template +void MetaServiceAsyncProcessor::process_dropZoneFromGroup(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + MetaService_dropZoneFromGroup_pargs args; + ::nebula::meta::cpp2::DropZoneFromGroupReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "MetaService.dropZoneFromGroup", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "dropZoneFromGroup"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_dropZoneFromGroup, throw_wrapped_dropZoneFromGroup, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_dropZoneFromGroup(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue MetaServiceAsyncProcessor::return_dropZoneFromGroup(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ExecResp const& _return) { + ProtocolOut_ prot; + MetaService_dropZoneFromGroup_presult result; + result.get<0>().value = const_cast< ::nebula::meta::cpp2::ExecResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("dropZoneFromGroup", &prot, protoSeqId, ctx, result); +} + +template +void MetaServiceAsyncProcessor::throw_wrapped_dropZoneFromGroup(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "dropZoneFromGroup"); + return; + } +} + +template +void MetaServiceAsyncProcessor::setUpAndProcess_getGroup(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &MetaServiceAsyncProcessor::process_getGroup, this); +} + +template +void MetaServiceAsyncProcessor::process_getGroup(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + MetaService_getGroup_pargs args; + ::nebula::meta::cpp2::GetGroupReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "MetaService.getGroup", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "getGroup"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_getGroup, throw_wrapped_getGroup, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_getGroup(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue MetaServiceAsyncProcessor::return_getGroup(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::GetGroupResp const& _return) { + ProtocolOut_ prot; + MetaService_getGroup_presult result; + result.get<0>().value = const_cast< ::nebula::meta::cpp2::GetGroupResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("getGroup", &prot, protoSeqId, ctx, result); +} + +template +void MetaServiceAsyncProcessor::throw_wrapped_getGroup(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "getGroup"); + return; + } +} + +template +void MetaServiceAsyncProcessor::setUpAndProcess_listGroups(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &MetaServiceAsyncProcessor::process_listGroups, this); +} + +template +void MetaServiceAsyncProcessor::process_listGroups(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + MetaService_listGroups_pargs args; + ::nebula::meta::cpp2::ListGroupsReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "MetaService.listGroups", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "listGroups"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_listGroups, throw_wrapped_listGroups, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_listGroups(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue MetaServiceAsyncProcessor::return_listGroups(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ListGroupsResp const& _return) { + ProtocolOut_ prot; + MetaService_listGroups_presult result; + result.get<0>().value = const_cast< ::nebula::meta::cpp2::ListGroupsResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("listGroups", &prot, protoSeqId, ctx, result); +} + +template +void MetaServiceAsyncProcessor::throw_wrapped_listGroups(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "listGroups"); + return; + } +} + +template +void MetaServiceAsyncProcessor::setUpAndProcess_createBackup(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &MetaServiceAsyncProcessor::process_createBackup, this); +} + +template +void MetaServiceAsyncProcessor::process_createBackup(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + MetaService_createBackup_pargs args; + ::nebula::meta::cpp2::CreateBackupReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "MetaService.createBackup", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "createBackup"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_createBackup, throw_wrapped_createBackup, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_createBackup(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue MetaServiceAsyncProcessor::return_createBackup(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::CreateBackupResp const& _return) { + ProtocolOut_ prot; + MetaService_createBackup_presult result; + result.get<0>().value = const_cast< ::nebula::meta::cpp2::CreateBackupResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("createBackup", &prot, protoSeqId, ctx, result); +} + +template +void MetaServiceAsyncProcessor::throw_wrapped_createBackup(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "createBackup"); + return; + } +} + +template +void MetaServiceAsyncProcessor::setUpAndProcess_restoreMeta(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &MetaServiceAsyncProcessor::process_restoreMeta, this); +} + +template +void MetaServiceAsyncProcessor::process_restoreMeta(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + MetaService_restoreMeta_pargs args; + ::nebula::meta::cpp2::RestoreMetaReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "MetaService.restoreMeta", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "restoreMeta"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_restoreMeta, throw_wrapped_restoreMeta, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_restoreMeta(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue MetaServiceAsyncProcessor::return_restoreMeta(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ExecResp const& _return) { + ProtocolOut_ prot; + MetaService_restoreMeta_presult result; + result.get<0>().value = const_cast< ::nebula::meta::cpp2::ExecResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("restoreMeta", &prot, protoSeqId, ctx, result); +} + +template +void MetaServiceAsyncProcessor::throw_wrapped_restoreMeta(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "restoreMeta"); + return; + } +} + +template +void MetaServiceAsyncProcessor::setUpAndProcess_addListener(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &MetaServiceAsyncProcessor::process_addListener, this); +} + +template +void MetaServiceAsyncProcessor::process_addListener(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + MetaService_addListener_pargs args; + ::nebula::meta::cpp2::AddListenerReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "MetaService.addListener", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "addListener"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_addListener, throw_wrapped_addListener, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_addListener(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue MetaServiceAsyncProcessor::return_addListener(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ExecResp const& _return) { + ProtocolOut_ prot; + MetaService_addListener_presult result; + result.get<0>().value = const_cast< ::nebula::meta::cpp2::ExecResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("addListener", &prot, protoSeqId, ctx, result); +} + +template +void MetaServiceAsyncProcessor::throw_wrapped_addListener(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "addListener"); + return; + } +} + +template +void MetaServiceAsyncProcessor::setUpAndProcess_removeListener(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &MetaServiceAsyncProcessor::process_removeListener, this); +} + +template +void MetaServiceAsyncProcessor::process_removeListener(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + MetaService_removeListener_pargs args; + ::nebula::meta::cpp2::RemoveListenerReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "MetaService.removeListener", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "removeListener"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_removeListener, throw_wrapped_removeListener, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_removeListener(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue MetaServiceAsyncProcessor::return_removeListener(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ExecResp const& _return) { + ProtocolOut_ prot; + MetaService_removeListener_presult result; + result.get<0>().value = const_cast< ::nebula::meta::cpp2::ExecResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("removeListener", &prot, protoSeqId, ctx, result); +} + +template +void MetaServiceAsyncProcessor::throw_wrapped_removeListener(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "removeListener"); + return; + } +} + +template +void MetaServiceAsyncProcessor::setUpAndProcess_listListener(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &MetaServiceAsyncProcessor::process_listListener, this); +} + +template +void MetaServiceAsyncProcessor::process_listListener(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + MetaService_listListener_pargs args; + ::nebula::meta::cpp2::ListListenerReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "MetaService.listListener", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "listListener"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_listListener, throw_wrapped_listListener, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_listListener(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue MetaServiceAsyncProcessor::return_listListener(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ListListenerResp const& _return) { + ProtocolOut_ prot; + MetaService_listListener_presult result; + result.get<0>().value = const_cast< ::nebula::meta::cpp2::ListListenerResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("listListener", &prot, protoSeqId, ctx, result); +} + +template +void MetaServiceAsyncProcessor::throw_wrapped_listListener(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "listListener"); + return; + } +} + +template +void MetaServiceAsyncProcessor::setUpAndProcess_getStats(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &MetaServiceAsyncProcessor::process_getStats, this); +} + +template +void MetaServiceAsyncProcessor::process_getStats(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + MetaService_getStats_pargs args; + ::nebula::meta::cpp2::GetStatsReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "MetaService.getStats", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "getStats"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_getStats, throw_wrapped_getStats, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_getStats(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue MetaServiceAsyncProcessor::return_getStats(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::GetStatsResp const& _return) { + ProtocolOut_ prot; + MetaService_getStats_presult result; + result.get<0>().value = const_cast< ::nebula::meta::cpp2::GetStatsResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("getStats", &prot, protoSeqId, ctx, result); +} + +template +void MetaServiceAsyncProcessor::throw_wrapped_getStats(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "getStats"); + return; + } +} + +template +void MetaServiceAsyncProcessor::setUpAndProcess_signInFTService(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &MetaServiceAsyncProcessor::process_signInFTService, this); +} + +template +void MetaServiceAsyncProcessor::process_signInFTService(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + MetaService_signInFTService_pargs args; + ::nebula::meta::cpp2::SignInFTServiceReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "MetaService.signInFTService", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "signInFTService"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_signInFTService, throw_wrapped_signInFTService, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_signInFTService(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue MetaServiceAsyncProcessor::return_signInFTService(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ExecResp const& _return) { + ProtocolOut_ prot; + MetaService_signInFTService_presult result; + result.get<0>().value = const_cast< ::nebula::meta::cpp2::ExecResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("signInFTService", &prot, protoSeqId, ctx, result); +} + +template +void MetaServiceAsyncProcessor::throw_wrapped_signInFTService(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "signInFTService"); + return; + } +} + +template +void MetaServiceAsyncProcessor::setUpAndProcess_signOutFTService(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &MetaServiceAsyncProcessor::process_signOutFTService, this); +} + +template +void MetaServiceAsyncProcessor::process_signOutFTService(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + MetaService_signOutFTService_pargs args; + ::nebula::meta::cpp2::SignOutFTServiceReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "MetaService.signOutFTService", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "signOutFTService"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_signOutFTService, throw_wrapped_signOutFTService, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_signOutFTService(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue MetaServiceAsyncProcessor::return_signOutFTService(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ExecResp const& _return) { + ProtocolOut_ prot; + MetaService_signOutFTService_presult result; + result.get<0>().value = const_cast< ::nebula::meta::cpp2::ExecResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("signOutFTService", &prot, protoSeqId, ctx, result); +} + +template +void MetaServiceAsyncProcessor::throw_wrapped_signOutFTService(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "signOutFTService"); + return; + } +} + +template +void MetaServiceAsyncProcessor::setUpAndProcess_listFTClients(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &MetaServiceAsyncProcessor::process_listFTClients, this); +} + +template +void MetaServiceAsyncProcessor::process_listFTClients(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + MetaService_listFTClients_pargs args; + ::nebula::meta::cpp2::ListFTClientsReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "MetaService.listFTClients", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "listFTClients"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_listFTClients, throw_wrapped_listFTClients, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_listFTClients(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue MetaServiceAsyncProcessor::return_listFTClients(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ListFTClientsResp const& _return) { + ProtocolOut_ prot; + MetaService_listFTClients_presult result; + result.get<0>().value = const_cast< ::nebula::meta::cpp2::ListFTClientsResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("listFTClients", &prot, protoSeqId, ctx, result); +} + +template +void MetaServiceAsyncProcessor::throw_wrapped_listFTClients(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "listFTClients"); + return; + } +} + +template +void MetaServiceAsyncProcessor::setUpAndProcess_createFTIndex(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &MetaServiceAsyncProcessor::process_createFTIndex, this); +} + +template +void MetaServiceAsyncProcessor::process_createFTIndex(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + MetaService_createFTIndex_pargs args; + ::nebula::meta::cpp2::CreateFTIndexReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "MetaService.createFTIndex", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "createFTIndex"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_createFTIndex, throw_wrapped_createFTIndex, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_createFTIndex(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue MetaServiceAsyncProcessor::return_createFTIndex(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ExecResp const& _return) { + ProtocolOut_ prot; + MetaService_createFTIndex_presult result; + result.get<0>().value = const_cast< ::nebula::meta::cpp2::ExecResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("createFTIndex", &prot, protoSeqId, ctx, result); +} + +template +void MetaServiceAsyncProcessor::throw_wrapped_createFTIndex(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "createFTIndex"); + return; + } +} + +template +void MetaServiceAsyncProcessor::setUpAndProcess_dropFTIndex(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &MetaServiceAsyncProcessor::process_dropFTIndex, this); +} + +template +void MetaServiceAsyncProcessor::process_dropFTIndex(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + MetaService_dropFTIndex_pargs args; + ::nebula::meta::cpp2::DropFTIndexReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "MetaService.dropFTIndex", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "dropFTIndex"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_dropFTIndex, throw_wrapped_dropFTIndex, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_dropFTIndex(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue MetaServiceAsyncProcessor::return_dropFTIndex(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ExecResp const& _return) { + ProtocolOut_ prot; + MetaService_dropFTIndex_presult result; + result.get<0>().value = const_cast< ::nebula::meta::cpp2::ExecResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("dropFTIndex", &prot, protoSeqId, ctx, result); +} + +template +void MetaServiceAsyncProcessor::throw_wrapped_dropFTIndex(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "dropFTIndex"); + return; + } +} + +template +void MetaServiceAsyncProcessor::setUpAndProcess_listFTIndexes(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &MetaServiceAsyncProcessor::process_listFTIndexes, this); +} + +template +void MetaServiceAsyncProcessor::process_listFTIndexes(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + MetaService_listFTIndexes_pargs args; + ::nebula::meta::cpp2::ListFTIndexesReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "MetaService.listFTIndexes", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "listFTIndexes"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_listFTIndexes, throw_wrapped_listFTIndexes, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_listFTIndexes(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue MetaServiceAsyncProcessor::return_listFTIndexes(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ListFTIndexesResp const& _return) { + ProtocolOut_ prot; + MetaService_listFTIndexes_presult result; + result.get<0>().value = const_cast< ::nebula::meta::cpp2::ListFTIndexesResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("listFTIndexes", &prot, protoSeqId, ctx, result); +} + +template +void MetaServiceAsyncProcessor::throw_wrapped_listFTIndexes(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "listFTIndexes"); + return; + } +} + +template +void MetaServiceAsyncProcessor::setUpAndProcess_createSession(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &MetaServiceAsyncProcessor::process_createSession, this); +} + +template +void MetaServiceAsyncProcessor::process_createSession(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + MetaService_createSession_pargs args; + ::nebula::meta::cpp2::CreateSessionReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "MetaService.createSession", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "createSession"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_createSession, throw_wrapped_createSession, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_createSession(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue MetaServiceAsyncProcessor::return_createSession(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::CreateSessionResp const& _return) { + ProtocolOut_ prot; + MetaService_createSession_presult result; + result.get<0>().value = const_cast< ::nebula::meta::cpp2::CreateSessionResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("createSession", &prot, protoSeqId, ctx, result); +} + +template +void MetaServiceAsyncProcessor::throw_wrapped_createSession(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "createSession"); + return; + } +} + +template +void MetaServiceAsyncProcessor::setUpAndProcess_updateSessions(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &MetaServiceAsyncProcessor::process_updateSessions, this); +} + +template +void MetaServiceAsyncProcessor::process_updateSessions(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + MetaService_updateSessions_pargs args; + ::nebula::meta::cpp2::UpdateSessionsReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "MetaService.updateSessions", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "updateSessions"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_updateSessions, throw_wrapped_updateSessions, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_updateSessions(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue MetaServiceAsyncProcessor::return_updateSessions(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::UpdateSessionsResp const& _return) { + ProtocolOut_ prot; + MetaService_updateSessions_presult result; + result.get<0>().value = const_cast< ::nebula::meta::cpp2::UpdateSessionsResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("updateSessions", &prot, protoSeqId, ctx, result); +} + +template +void MetaServiceAsyncProcessor::throw_wrapped_updateSessions(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "updateSessions"); + return; + } +} + +template +void MetaServiceAsyncProcessor::setUpAndProcess_listSessions(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &MetaServiceAsyncProcessor::process_listSessions, this); +} + +template +void MetaServiceAsyncProcessor::process_listSessions(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + MetaService_listSessions_pargs args; + ::nebula::meta::cpp2::ListSessionsReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "MetaService.listSessions", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "listSessions"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_listSessions, throw_wrapped_listSessions, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_listSessions(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue MetaServiceAsyncProcessor::return_listSessions(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ListSessionsResp const& _return) { + ProtocolOut_ prot; + MetaService_listSessions_presult result; + result.get<0>().value = const_cast< ::nebula::meta::cpp2::ListSessionsResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("listSessions", &prot, protoSeqId, ctx, result); +} + +template +void MetaServiceAsyncProcessor::throw_wrapped_listSessions(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "listSessions"); + return; + } +} + +template +void MetaServiceAsyncProcessor::setUpAndProcess_getSession(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &MetaServiceAsyncProcessor::process_getSession, this); +} + +template +void MetaServiceAsyncProcessor::process_getSession(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + MetaService_getSession_pargs args; + ::nebula::meta::cpp2::GetSessionReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "MetaService.getSession", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "getSession"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_getSession, throw_wrapped_getSession, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_getSession(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue MetaServiceAsyncProcessor::return_getSession(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::GetSessionResp const& _return) { + ProtocolOut_ prot; + MetaService_getSession_presult result; + result.get<0>().value = const_cast< ::nebula::meta::cpp2::GetSessionResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("getSession", &prot, protoSeqId, ctx, result); +} + +template +void MetaServiceAsyncProcessor::throw_wrapped_getSession(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "getSession"); + return; + } +} + +template +void MetaServiceAsyncProcessor::setUpAndProcess_removeSession(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &MetaServiceAsyncProcessor::process_removeSession, this); +} + +template +void MetaServiceAsyncProcessor::process_removeSession(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + MetaService_removeSession_pargs args; + ::nebula::meta::cpp2::RemoveSessionReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "MetaService.removeSession", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "removeSession"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_removeSession, throw_wrapped_removeSession, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_removeSession(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue MetaServiceAsyncProcessor::return_removeSession(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ExecResp const& _return) { + ProtocolOut_ prot; + MetaService_removeSession_presult result; + result.get<0>().value = const_cast< ::nebula::meta::cpp2::ExecResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("removeSession", &prot, protoSeqId, ctx, result); +} + +template +void MetaServiceAsyncProcessor::throw_wrapped_removeSession(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "removeSession"); + return; + } +} + +template +void MetaServiceAsyncProcessor::setUpAndProcess_killQuery(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &MetaServiceAsyncProcessor::process_killQuery, this); +} + +template +void MetaServiceAsyncProcessor::process_killQuery(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + MetaService_killQuery_pargs args; + ::nebula::meta::cpp2::KillQueryReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "MetaService.killQuery", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "killQuery"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_killQuery, throw_wrapped_killQuery, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_killQuery(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue MetaServiceAsyncProcessor::return_killQuery(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ExecResp const& _return) { + ProtocolOut_ prot; + MetaService_killQuery_presult result; + result.get<0>().value = const_cast< ::nebula::meta::cpp2::ExecResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("killQuery", &prot, protoSeqId, ctx, result); +} + +template +void MetaServiceAsyncProcessor::throw_wrapped_killQuery(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "killQuery"); + return; + } +} + +template +void MetaServiceAsyncProcessor::setUpAndProcess_reportTaskFinish(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &MetaServiceAsyncProcessor::process_reportTaskFinish, this); +} + +template +void MetaServiceAsyncProcessor::process_reportTaskFinish(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + MetaService_reportTaskFinish_pargs args; + ::nebula::meta::cpp2::ReportTaskReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "MetaService.reportTaskFinish", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "reportTaskFinish"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_reportTaskFinish, throw_wrapped_reportTaskFinish, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_reportTaskFinish(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue MetaServiceAsyncProcessor::return_reportTaskFinish(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ExecResp const& _return) { + ProtocolOut_ prot; + MetaService_reportTaskFinish_presult result; + result.get<0>().value = const_cast< ::nebula::meta::cpp2::ExecResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("reportTaskFinish", &prot, protoSeqId, ctx, result); +} + +template +void MetaServiceAsyncProcessor::throw_wrapped_reportTaskFinish(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "reportTaskFinish"); + return; + } +} + +template +void MetaServiceAsyncProcessor::setUpAndProcess_listCluster(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &MetaServiceAsyncProcessor::process_listCluster, this); +} + +template +void MetaServiceAsyncProcessor::process_listCluster(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + MetaService_listCluster_pargs args; + ::nebula::meta::cpp2::ListClusterInfoReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "MetaService.listCluster", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "listCluster"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_listCluster, throw_wrapped_listCluster, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_listCluster(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue MetaServiceAsyncProcessor::return_listCluster(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::ListClusterInfoResp const& _return) { + ProtocolOut_ prot; + MetaService_listCluster_presult result; + result.get<0>().value = const_cast< ::nebula::meta::cpp2::ListClusterInfoResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("listCluster", &prot, protoSeqId, ctx, result); +} + +template +void MetaServiceAsyncProcessor::throw_wrapped_listCluster(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "listCluster"); + return; + } +} + +template +void MetaServiceAsyncProcessor::setUpAndProcess_getMetaDirInfo(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &MetaServiceAsyncProcessor::process_getMetaDirInfo, this); +} + +template +void MetaServiceAsyncProcessor::process_getMetaDirInfo(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + MetaService_getMetaDirInfo_pargs args; + ::nebula::meta::cpp2::GetMetaDirInfoReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "MetaService.getMetaDirInfo", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "getMetaDirInfo"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_getMetaDirInfo, throw_wrapped_getMetaDirInfo, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_getMetaDirInfo(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue MetaServiceAsyncProcessor::return_getMetaDirInfo(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::GetMetaDirInfoResp const& _return) { + ProtocolOut_ prot; + MetaService_getMetaDirInfo_presult result; + result.get<0>().value = const_cast< ::nebula::meta::cpp2::GetMetaDirInfoResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("getMetaDirInfo", &prot, protoSeqId, ctx, result); +} + +template +void MetaServiceAsyncProcessor::throw_wrapped_getMetaDirInfo(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "getMetaDirInfo"); + return; + } +} + +template +void MetaServiceAsyncProcessor::setUpAndProcess_verifyClientVersion(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &MetaServiceAsyncProcessor::process_verifyClientVersion, this); +} + +template +void MetaServiceAsyncProcessor::process_verifyClientVersion(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + MetaService_verifyClientVersion_pargs args; + ::nebula::meta::cpp2::VerifyClientVersionReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "MetaService.verifyClientVersion", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "verifyClientVersion"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_verifyClientVersion, throw_wrapped_verifyClientVersion, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_verifyClientVersion(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue MetaServiceAsyncProcessor::return_verifyClientVersion(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::meta::cpp2::VerifyClientVersionResp const& _return) { + ProtocolOut_ prot; + MetaService_verifyClientVersion_presult result; + result.get<0>().value = const_cast< ::nebula::meta::cpp2::VerifyClientVersionResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("verifyClientVersion", &prot, protoSeqId, ctx, result); +} + +template +void MetaServiceAsyncProcessor::throw_wrapped_verifyClientVersion(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "verifyClientVersion"); + return; + } +} + + +}}} // nebula::meta::cpp2 diff --git a/src/interface/gen-cpp2/MetaServiceAsyncClient.cpp b/src/interface/gen-cpp2/MetaServiceAsyncClient.cpp new file mode 100644 index 00000000..9004c465 --- /dev/null +++ b/src/interface/gen-cpp2/MetaServiceAsyncClient.cpp @@ -0,0 +1,16397 @@ +/** + * Autogenerated by Thrift for meta.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ + +#include "MetaServiceAsyncClient.h" + +#include + +namespace nebula { namespace meta { namespace cpp2 { +typedef apache::thrift::ThriftPresult> MetaService_createSpace_pargs; +typedef apache::thrift::ThriftPresult> MetaService_createSpace_presult; +typedef apache::thrift::ThriftPresult> MetaService_dropSpace_pargs; +typedef apache::thrift::ThriftPresult> MetaService_dropSpace_presult; +typedef apache::thrift::ThriftPresult> MetaService_getSpace_pargs; +typedef apache::thrift::ThriftPresult> MetaService_getSpace_presult; +typedef apache::thrift::ThriftPresult> MetaService_listSpaces_pargs; +typedef apache::thrift::ThriftPresult> MetaService_listSpaces_presult; +typedef apache::thrift::ThriftPresult> MetaService_createSpaceAs_pargs; +typedef apache::thrift::ThriftPresult> MetaService_createSpaceAs_presult; +typedef apache::thrift::ThriftPresult> MetaService_createTag_pargs; +typedef apache::thrift::ThriftPresult> MetaService_createTag_presult; +typedef apache::thrift::ThriftPresult> MetaService_alterTag_pargs; +typedef apache::thrift::ThriftPresult> MetaService_alterTag_presult; +typedef apache::thrift::ThriftPresult> MetaService_dropTag_pargs; +typedef apache::thrift::ThriftPresult> MetaService_dropTag_presult; +typedef apache::thrift::ThriftPresult> MetaService_getTag_pargs; +typedef apache::thrift::ThriftPresult> MetaService_getTag_presult; +typedef apache::thrift::ThriftPresult> MetaService_listTags_pargs; +typedef apache::thrift::ThriftPresult> MetaService_listTags_presult; +typedef apache::thrift::ThriftPresult> MetaService_createEdge_pargs; +typedef apache::thrift::ThriftPresult> MetaService_createEdge_presult; +typedef apache::thrift::ThriftPresult> MetaService_alterEdge_pargs; +typedef apache::thrift::ThriftPresult> MetaService_alterEdge_presult; +typedef apache::thrift::ThriftPresult> MetaService_dropEdge_pargs; +typedef apache::thrift::ThriftPresult> MetaService_dropEdge_presult; +typedef apache::thrift::ThriftPresult> MetaService_getEdge_pargs; +typedef apache::thrift::ThriftPresult> MetaService_getEdge_presult; +typedef apache::thrift::ThriftPresult> MetaService_listEdges_pargs; +typedef apache::thrift::ThriftPresult> MetaService_listEdges_presult; +typedef apache::thrift::ThriftPresult> MetaService_listHosts_pargs; +typedef apache::thrift::ThriftPresult> MetaService_listHosts_presult; +typedef apache::thrift::ThriftPresult> MetaService_getPartsAlloc_pargs; +typedef apache::thrift::ThriftPresult> MetaService_getPartsAlloc_presult; +typedef apache::thrift::ThriftPresult> MetaService_listParts_pargs; +typedef apache::thrift::ThriftPresult> MetaService_listParts_presult; +typedef apache::thrift::ThriftPresult> MetaService_multiPut_pargs; +typedef apache::thrift::ThriftPresult> MetaService_multiPut_presult; +typedef apache::thrift::ThriftPresult> MetaService_get_pargs; +typedef apache::thrift::ThriftPresult> MetaService_get_presult; +typedef apache::thrift::ThriftPresult> MetaService_multiGet_pargs; +typedef apache::thrift::ThriftPresult> MetaService_multiGet_presult; +typedef apache::thrift::ThriftPresult> MetaService_remove_pargs; +typedef apache::thrift::ThriftPresult> MetaService_remove_presult; +typedef apache::thrift::ThriftPresult> MetaService_removeRange_pargs; +typedef apache::thrift::ThriftPresult> MetaService_removeRange_presult; +typedef apache::thrift::ThriftPresult> MetaService_scan_pargs; +typedef apache::thrift::ThriftPresult> MetaService_scan_presult; +typedef apache::thrift::ThriftPresult> MetaService_createTagIndex_pargs; +typedef apache::thrift::ThriftPresult> MetaService_createTagIndex_presult; +typedef apache::thrift::ThriftPresult> MetaService_dropTagIndex_pargs; +typedef apache::thrift::ThriftPresult> MetaService_dropTagIndex_presult; +typedef apache::thrift::ThriftPresult> MetaService_getTagIndex_pargs; +typedef apache::thrift::ThriftPresult> MetaService_getTagIndex_presult; +typedef apache::thrift::ThriftPresult> MetaService_listTagIndexes_pargs; +typedef apache::thrift::ThriftPresult> MetaService_listTagIndexes_presult; +typedef apache::thrift::ThriftPresult> MetaService_rebuildTagIndex_pargs; +typedef apache::thrift::ThriftPresult> MetaService_rebuildTagIndex_presult; +typedef apache::thrift::ThriftPresult> MetaService_listTagIndexStatus_pargs; +typedef apache::thrift::ThriftPresult> MetaService_listTagIndexStatus_presult; +typedef apache::thrift::ThriftPresult> MetaService_createEdgeIndex_pargs; +typedef apache::thrift::ThriftPresult> MetaService_createEdgeIndex_presult; +typedef apache::thrift::ThriftPresult> MetaService_dropEdgeIndex_pargs; +typedef apache::thrift::ThriftPresult> MetaService_dropEdgeIndex_presult; +typedef apache::thrift::ThriftPresult> MetaService_getEdgeIndex_pargs; +typedef apache::thrift::ThriftPresult> MetaService_getEdgeIndex_presult; +typedef apache::thrift::ThriftPresult> MetaService_listEdgeIndexes_pargs; +typedef apache::thrift::ThriftPresult> MetaService_listEdgeIndexes_presult; +typedef apache::thrift::ThriftPresult> MetaService_rebuildEdgeIndex_pargs; +typedef apache::thrift::ThriftPresult> MetaService_rebuildEdgeIndex_presult; +typedef apache::thrift::ThriftPresult> MetaService_listEdgeIndexStatus_pargs; +typedef apache::thrift::ThriftPresult> MetaService_listEdgeIndexStatus_presult; +typedef apache::thrift::ThriftPresult> MetaService_createUser_pargs; +typedef apache::thrift::ThriftPresult> MetaService_createUser_presult; +typedef apache::thrift::ThriftPresult> MetaService_dropUser_pargs; +typedef apache::thrift::ThriftPresult> MetaService_dropUser_presult; +typedef apache::thrift::ThriftPresult> MetaService_alterUser_pargs; +typedef apache::thrift::ThriftPresult> MetaService_alterUser_presult; +typedef apache::thrift::ThriftPresult> MetaService_grantRole_pargs; +typedef apache::thrift::ThriftPresult> MetaService_grantRole_presult; +typedef apache::thrift::ThriftPresult> MetaService_revokeRole_pargs; +typedef apache::thrift::ThriftPresult> MetaService_revokeRole_presult; +typedef apache::thrift::ThriftPresult> MetaService_listUsers_pargs; +typedef apache::thrift::ThriftPresult> MetaService_listUsers_presult; +typedef apache::thrift::ThriftPresult> MetaService_listRoles_pargs; +typedef apache::thrift::ThriftPresult> MetaService_listRoles_presult; +typedef apache::thrift::ThriftPresult> MetaService_getUserRoles_pargs; +typedef apache::thrift::ThriftPresult> MetaService_getUserRoles_presult; +typedef apache::thrift::ThriftPresult> MetaService_changePassword_pargs; +typedef apache::thrift::ThriftPresult> MetaService_changePassword_presult; +typedef apache::thrift::ThriftPresult> MetaService_heartBeat_pargs; +typedef apache::thrift::ThriftPresult> MetaService_heartBeat_presult; +typedef apache::thrift::ThriftPresult> MetaService_balance_pargs; +typedef apache::thrift::ThriftPresult> MetaService_balance_presult; +typedef apache::thrift::ThriftPresult> MetaService_leaderBalance_pargs; +typedef apache::thrift::ThriftPresult> MetaService_leaderBalance_presult; +typedef apache::thrift::ThriftPresult> MetaService_regConfig_pargs; +typedef apache::thrift::ThriftPresult> MetaService_regConfig_presult; +typedef apache::thrift::ThriftPresult> MetaService_getConfig_pargs; +typedef apache::thrift::ThriftPresult> MetaService_getConfig_presult; +typedef apache::thrift::ThriftPresult> MetaService_setConfig_pargs; +typedef apache::thrift::ThriftPresult> MetaService_setConfig_presult; +typedef apache::thrift::ThriftPresult> MetaService_listConfigs_pargs; +typedef apache::thrift::ThriftPresult> MetaService_listConfigs_presult; +typedef apache::thrift::ThriftPresult> MetaService_createSnapshot_pargs; +typedef apache::thrift::ThriftPresult> MetaService_createSnapshot_presult; +typedef apache::thrift::ThriftPresult> MetaService_dropSnapshot_pargs; +typedef apache::thrift::ThriftPresult> MetaService_dropSnapshot_presult; +typedef apache::thrift::ThriftPresult> MetaService_listSnapshots_pargs; +typedef apache::thrift::ThriftPresult> MetaService_listSnapshots_presult; +typedef apache::thrift::ThriftPresult> MetaService_runAdminJob_pargs; +typedef apache::thrift::ThriftPresult> MetaService_runAdminJob_presult; +typedef apache::thrift::ThriftPresult> MetaService_addZone_pargs; +typedef apache::thrift::ThriftPresult> MetaService_addZone_presult; +typedef apache::thrift::ThriftPresult> MetaService_dropZone_pargs; +typedef apache::thrift::ThriftPresult> MetaService_dropZone_presult; +typedef apache::thrift::ThriftPresult> MetaService_addHostIntoZone_pargs; +typedef apache::thrift::ThriftPresult> MetaService_addHostIntoZone_presult; +typedef apache::thrift::ThriftPresult> MetaService_dropHostFromZone_pargs; +typedef apache::thrift::ThriftPresult> MetaService_dropHostFromZone_presult; +typedef apache::thrift::ThriftPresult> MetaService_getZone_pargs; +typedef apache::thrift::ThriftPresult> MetaService_getZone_presult; +typedef apache::thrift::ThriftPresult> MetaService_listZones_pargs; +typedef apache::thrift::ThriftPresult> MetaService_listZones_presult; +typedef apache::thrift::ThriftPresult> MetaService_addGroup_pargs; +typedef apache::thrift::ThriftPresult> MetaService_addGroup_presult; +typedef apache::thrift::ThriftPresult> MetaService_dropGroup_pargs; +typedef apache::thrift::ThriftPresult> MetaService_dropGroup_presult; +typedef apache::thrift::ThriftPresult> MetaService_addZoneIntoGroup_pargs; +typedef apache::thrift::ThriftPresult> MetaService_addZoneIntoGroup_presult; +typedef apache::thrift::ThriftPresult> MetaService_dropZoneFromGroup_pargs; +typedef apache::thrift::ThriftPresult> MetaService_dropZoneFromGroup_presult; +typedef apache::thrift::ThriftPresult> MetaService_getGroup_pargs; +typedef apache::thrift::ThriftPresult> MetaService_getGroup_presult; +typedef apache::thrift::ThriftPresult> MetaService_listGroups_pargs; +typedef apache::thrift::ThriftPresult> MetaService_listGroups_presult; +typedef apache::thrift::ThriftPresult> MetaService_createBackup_pargs; +typedef apache::thrift::ThriftPresult> MetaService_createBackup_presult; +typedef apache::thrift::ThriftPresult> MetaService_restoreMeta_pargs; +typedef apache::thrift::ThriftPresult> MetaService_restoreMeta_presult; +typedef apache::thrift::ThriftPresult> MetaService_addListener_pargs; +typedef apache::thrift::ThriftPresult> MetaService_addListener_presult; +typedef apache::thrift::ThriftPresult> MetaService_removeListener_pargs; +typedef apache::thrift::ThriftPresult> MetaService_removeListener_presult; +typedef apache::thrift::ThriftPresult> MetaService_listListener_pargs; +typedef apache::thrift::ThriftPresult> MetaService_listListener_presult; +typedef apache::thrift::ThriftPresult> MetaService_getStats_pargs; +typedef apache::thrift::ThriftPresult> MetaService_getStats_presult; +typedef apache::thrift::ThriftPresult> MetaService_signInFTService_pargs; +typedef apache::thrift::ThriftPresult> MetaService_signInFTService_presult; +typedef apache::thrift::ThriftPresult> MetaService_signOutFTService_pargs; +typedef apache::thrift::ThriftPresult> MetaService_signOutFTService_presult; +typedef apache::thrift::ThriftPresult> MetaService_listFTClients_pargs; +typedef apache::thrift::ThriftPresult> MetaService_listFTClients_presult; +typedef apache::thrift::ThriftPresult> MetaService_createFTIndex_pargs; +typedef apache::thrift::ThriftPresult> MetaService_createFTIndex_presult; +typedef apache::thrift::ThriftPresult> MetaService_dropFTIndex_pargs; +typedef apache::thrift::ThriftPresult> MetaService_dropFTIndex_presult; +typedef apache::thrift::ThriftPresult> MetaService_listFTIndexes_pargs; +typedef apache::thrift::ThriftPresult> MetaService_listFTIndexes_presult; +typedef apache::thrift::ThriftPresult> MetaService_createSession_pargs; +typedef apache::thrift::ThriftPresult> MetaService_createSession_presult; +typedef apache::thrift::ThriftPresult> MetaService_updateSessions_pargs; +typedef apache::thrift::ThriftPresult> MetaService_updateSessions_presult; +typedef apache::thrift::ThriftPresult> MetaService_listSessions_pargs; +typedef apache::thrift::ThriftPresult> MetaService_listSessions_presult; +typedef apache::thrift::ThriftPresult> MetaService_getSession_pargs; +typedef apache::thrift::ThriftPresult> MetaService_getSession_presult; +typedef apache::thrift::ThriftPresult> MetaService_removeSession_pargs; +typedef apache::thrift::ThriftPresult> MetaService_removeSession_presult; +typedef apache::thrift::ThriftPresult> MetaService_killQuery_pargs; +typedef apache::thrift::ThriftPresult> MetaService_killQuery_presult; +typedef apache::thrift::ThriftPresult> MetaService_reportTaskFinish_pargs; +typedef apache::thrift::ThriftPresult> MetaService_reportTaskFinish_presult; +typedef apache::thrift::ThriftPresult> MetaService_listCluster_pargs; +typedef apache::thrift::ThriftPresult> MetaService_listCluster_presult; +typedef apache::thrift::ThriftPresult> MetaService_getMetaDirInfo_pargs; +typedef apache::thrift::ThriftPresult> MetaService_getMetaDirInfo_presult; +typedef apache::thrift::ThriftPresult> MetaService_verifyClientVersion_pargs; +typedef apache::thrift::ThriftPresult> MetaService_verifyClientVersion_presult; + +template +void MetaServiceAsyncClient::createSpaceT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::CreateSpaceReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + MetaService_createSpace_pargs args; + args.get<0>().value = const_cast< ::nebula::meta::cpp2::CreateSpaceReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "createSpace"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void MetaServiceAsyncClient::dropSpaceT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::DropSpaceReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + MetaService_dropSpace_pargs args; + args.get<0>().value = const_cast< ::nebula::meta::cpp2::DropSpaceReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "dropSpace"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void MetaServiceAsyncClient::getSpaceT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::GetSpaceReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + MetaService_getSpace_pargs args; + args.get<0>().value = const_cast< ::nebula::meta::cpp2::GetSpaceReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "getSpace"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void MetaServiceAsyncClient::listSpacesT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::ListSpacesReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + MetaService_listSpaces_pargs args; + args.get<0>().value = const_cast< ::nebula::meta::cpp2::ListSpacesReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "listSpaces"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void MetaServiceAsyncClient::createSpaceAsT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::CreateSpaceAsReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + MetaService_createSpaceAs_pargs args; + args.get<0>().value = const_cast< ::nebula::meta::cpp2::CreateSpaceAsReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "createSpaceAs"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void MetaServiceAsyncClient::createTagT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::CreateTagReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + MetaService_createTag_pargs args; + args.get<0>().value = const_cast< ::nebula::meta::cpp2::CreateTagReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "createTag"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void MetaServiceAsyncClient::alterTagT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::AlterTagReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + MetaService_alterTag_pargs args; + args.get<0>().value = const_cast< ::nebula::meta::cpp2::AlterTagReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "alterTag"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void MetaServiceAsyncClient::dropTagT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::DropTagReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + MetaService_dropTag_pargs args; + args.get<0>().value = const_cast< ::nebula::meta::cpp2::DropTagReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "dropTag"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void MetaServiceAsyncClient::getTagT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::GetTagReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + MetaService_getTag_pargs args; + args.get<0>().value = const_cast< ::nebula::meta::cpp2::GetTagReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "getTag"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void MetaServiceAsyncClient::listTagsT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::ListTagsReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + MetaService_listTags_pargs args; + args.get<0>().value = const_cast< ::nebula::meta::cpp2::ListTagsReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "listTags"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void MetaServiceAsyncClient::createEdgeT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::CreateEdgeReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + MetaService_createEdge_pargs args; + args.get<0>().value = const_cast< ::nebula::meta::cpp2::CreateEdgeReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "createEdge"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void MetaServiceAsyncClient::alterEdgeT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::AlterEdgeReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + MetaService_alterEdge_pargs args; + args.get<0>().value = const_cast< ::nebula::meta::cpp2::AlterEdgeReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "alterEdge"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void MetaServiceAsyncClient::dropEdgeT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::DropEdgeReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + MetaService_dropEdge_pargs args; + args.get<0>().value = const_cast< ::nebula::meta::cpp2::DropEdgeReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "dropEdge"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void MetaServiceAsyncClient::getEdgeT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::GetEdgeReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + MetaService_getEdge_pargs args; + args.get<0>().value = const_cast< ::nebula::meta::cpp2::GetEdgeReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "getEdge"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void MetaServiceAsyncClient::listEdgesT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::ListEdgesReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + MetaService_listEdges_pargs args; + args.get<0>().value = const_cast< ::nebula::meta::cpp2::ListEdgesReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "listEdges"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void MetaServiceAsyncClient::listHostsT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::ListHostsReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + MetaService_listHosts_pargs args; + args.get<0>().value = const_cast< ::nebula::meta::cpp2::ListHostsReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "listHosts"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void MetaServiceAsyncClient::getPartsAllocT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::GetPartsAllocReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + MetaService_getPartsAlloc_pargs args; + args.get<0>().value = const_cast< ::nebula::meta::cpp2::GetPartsAllocReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "getPartsAlloc"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void MetaServiceAsyncClient::listPartsT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::ListPartsReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + MetaService_listParts_pargs args; + args.get<0>().value = const_cast< ::nebula::meta::cpp2::ListPartsReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "listParts"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void MetaServiceAsyncClient::multiPutT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::MultiPutReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + MetaService_multiPut_pargs args; + args.get<0>().value = const_cast< ::nebula::meta::cpp2::MultiPutReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "multiPut"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void MetaServiceAsyncClient::getT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::GetReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + MetaService_get_pargs args; + args.get<0>().value = const_cast< ::nebula::meta::cpp2::GetReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "get"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void MetaServiceAsyncClient::multiGetT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::MultiGetReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + MetaService_multiGet_pargs args; + args.get<0>().value = const_cast< ::nebula::meta::cpp2::MultiGetReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "multiGet"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void MetaServiceAsyncClient::removeT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::RemoveReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + MetaService_remove_pargs args; + args.get<0>().value = const_cast< ::nebula::meta::cpp2::RemoveReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "remove"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void MetaServiceAsyncClient::removeRangeT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::RemoveRangeReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + MetaService_removeRange_pargs args; + args.get<0>().value = const_cast< ::nebula::meta::cpp2::RemoveRangeReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "removeRange"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void MetaServiceAsyncClient::scanT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::ScanReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + MetaService_scan_pargs args; + args.get<0>().value = const_cast< ::nebula::meta::cpp2::ScanReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "scan"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void MetaServiceAsyncClient::createTagIndexT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::CreateTagIndexReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + MetaService_createTagIndex_pargs args; + args.get<0>().value = const_cast< ::nebula::meta::cpp2::CreateTagIndexReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "createTagIndex"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void MetaServiceAsyncClient::dropTagIndexT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::DropTagIndexReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + MetaService_dropTagIndex_pargs args; + args.get<0>().value = const_cast< ::nebula::meta::cpp2::DropTagIndexReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "dropTagIndex"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void MetaServiceAsyncClient::getTagIndexT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::GetTagIndexReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + MetaService_getTagIndex_pargs args; + args.get<0>().value = const_cast< ::nebula::meta::cpp2::GetTagIndexReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "getTagIndex"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void MetaServiceAsyncClient::listTagIndexesT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::ListTagIndexesReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + MetaService_listTagIndexes_pargs args; + args.get<0>().value = const_cast< ::nebula::meta::cpp2::ListTagIndexesReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "listTagIndexes"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void MetaServiceAsyncClient::rebuildTagIndexT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::RebuildIndexReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + MetaService_rebuildTagIndex_pargs args; + args.get<0>().value = const_cast< ::nebula::meta::cpp2::RebuildIndexReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "rebuildTagIndex"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void MetaServiceAsyncClient::listTagIndexStatusT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::ListIndexStatusReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + MetaService_listTagIndexStatus_pargs args; + args.get<0>().value = const_cast< ::nebula::meta::cpp2::ListIndexStatusReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "listTagIndexStatus"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void MetaServiceAsyncClient::createEdgeIndexT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::CreateEdgeIndexReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + MetaService_createEdgeIndex_pargs args; + args.get<0>().value = const_cast< ::nebula::meta::cpp2::CreateEdgeIndexReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "createEdgeIndex"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void MetaServiceAsyncClient::dropEdgeIndexT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::DropEdgeIndexReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + MetaService_dropEdgeIndex_pargs args; + args.get<0>().value = const_cast< ::nebula::meta::cpp2::DropEdgeIndexReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "dropEdgeIndex"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void MetaServiceAsyncClient::getEdgeIndexT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::GetEdgeIndexReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + MetaService_getEdgeIndex_pargs args; + args.get<0>().value = const_cast< ::nebula::meta::cpp2::GetEdgeIndexReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "getEdgeIndex"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void MetaServiceAsyncClient::listEdgeIndexesT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::ListEdgeIndexesReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + MetaService_listEdgeIndexes_pargs args; + args.get<0>().value = const_cast< ::nebula::meta::cpp2::ListEdgeIndexesReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "listEdgeIndexes"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void MetaServiceAsyncClient::rebuildEdgeIndexT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::RebuildIndexReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + MetaService_rebuildEdgeIndex_pargs args; + args.get<0>().value = const_cast< ::nebula::meta::cpp2::RebuildIndexReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "rebuildEdgeIndex"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void MetaServiceAsyncClient::listEdgeIndexStatusT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::ListIndexStatusReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + MetaService_listEdgeIndexStatus_pargs args; + args.get<0>().value = const_cast< ::nebula::meta::cpp2::ListIndexStatusReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "listEdgeIndexStatus"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void MetaServiceAsyncClient::createUserT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::CreateUserReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + MetaService_createUser_pargs args; + args.get<0>().value = const_cast< ::nebula::meta::cpp2::CreateUserReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "createUser"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void MetaServiceAsyncClient::dropUserT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::DropUserReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + MetaService_dropUser_pargs args; + args.get<0>().value = const_cast< ::nebula::meta::cpp2::DropUserReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "dropUser"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void MetaServiceAsyncClient::alterUserT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::AlterUserReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + MetaService_alterUser_pargs args; + args.get<0>().value = const_cast< ::nebula::meta::cpp2::AlterUserReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "alterUser"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void MetaServiceAsyncClient::grantRoleT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::GrantRoleReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + MetaService_grantRole_pargs args; + args.get<0>().value = const_cast< ::nebula::meta::cpp2::GrantRoleReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "grantRole"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void MetaServiceAsyncClient::revokeRoleT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::RevokeRoleReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + MetaService_revokeRole_pargs args; + args.get<0>().value = const_cast< ::nebula::meta::cpp2::RevokeRoleReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "revokeRole"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void MetaServiceAsyncClient::listUsersT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::ListUsersReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + MetaService_listUsers_pargs args; + args.get<0>().value = const_cast< ::nebula::meta::cpp2::ListUsersReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "listUsers"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void MetaServiceAsyncClient::listRolesT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::ListRolesReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + MetaService_listRoles_pargs args; + args.get<0>().value = const_cast< ::nebula::meta::cpp2::ListRolesReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "listRoles"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void MetaServiceAsyncClient::getUserRolesT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::GetUserRolesReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + MetaService_getUserRoles_pargs args; + args.get<0>().value = const_cast< ::nebula::meta::cpp2::GetUserRolesReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "getUserRoles"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void MetaServiceAsyncClient::changePasswordT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::ChangePasswordReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + MetaService_changePassword_pargs args; + args.get<0>().value = const_cast< ::nebula::meta::cpp2::ChangePasswordReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "changePassword"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void MetaServiceAsyncClient::heartBeatT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::HBReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + MetaService_heartBeat_pargs args; + args.get<0>().value = const_cast< ::nebula::meta::cpp2::HBReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "heartBeat"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void MetaServiceAsyncClient::balanceT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::BalanceReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + MetaService_balance_pargs args; + args.get<0>().value = const_cast< ::nebula::meta::cpp2::BalanceReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "balance"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void MetaServiceAsyncClient::leaderBalanceT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::LeaderBalanceReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + MetaService_leaderBalance_pargs args; + args.get<0>().value = const_cast< ::nebula::meta::cpp2::LeaderBalanceReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "leaderBalance"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void MetaServiceAsyncClient::regConfigT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::RegConfigReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + MetaService_regConfig_pargs args; + args.get<0>().value = const_cast< ::nebula::meta::cpp2::RegConfigReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "regConfig"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void MetaServiceAsyncClient::getConfigT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::GetConfigReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + MetaService_getConfig_pargs args; + args.get<0>().value = const_cast< ::nebula::meta::cpp2::GetConfigReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "getConfig"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void MetaServiceAsyncClient::setConfigT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::SetConfigReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + MetaService_setConfig_pargs args; + args.get<0>().value = const_cast< ::nebula::meta::cpp2::SetConfigReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "setConfig"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void MetaServiceAsyncClient::listConfigsT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::ListConfigsReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + MetaService_listConfigs_pargs args; + args.get<0>().value = const_cast< ::nebula::meta::cpp2::ListConfigsReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "listConfigs"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void MetaServiceAsyncClient::createSnapshotT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::CreateSnapshotReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + MetaService_createSnapshot_pargs args; + args.get<0>().value = const_cast< ::nebula::meta::cpp2::CreateSnapshotReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "createSnapshot"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void MetaServiceAsyncClient::dropSnapshotT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::DropSnapshotReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + MetaService_dropSnapshot_pargs args; + args.get<0>().value = const_cast< ::nebula::meta::cpp2::DropSnapshotReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "dropSnapshot"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void MetaServiceAsyncClient::listSnapshotsT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::ListSnapshotsReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + MetaService_listSnapshots_pargs args; + args.get<0>().value = const_cast< ::nebula::meta::cpp2::ListSnapshotsReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "listSnapshots"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void MetaServiceAsyncClient::runAdminJobT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::AdminJobReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + MetaService_runAdminJob_pargs args; + args.get<0>().value = const_cast< ::nebula::meta::cpp2::AdminJobReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "runAdminJob"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void MetaServiceAsyncClient::addZoneT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::AddZoneReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + MetaService_addZone_pargs args; + args.get<0>().value = const_cast< ::nebula::meta::cpp2::AddZoneReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "addZone"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void MetaServiceAsyncClient::dropZoneT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::DropZoneReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + MetaService_dropZone_pargs args; + args.get<0>().value = const_cast< ::nebula::meta::cpp2::DropZoneReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "dropZone"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void MetaServiceAsyncClient::addHostIntoZoneT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::AddHostIntoZoneReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + MetaService_addHostIntoZone_pargs args; + args.get<0>().value = const_cast< ::nebula::meta::cpp2::AddHostIntoZoneReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "addHostIntoZone"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void MetaServiceAsyncClient::dropHostFromZoneT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::DropHostFromZoneReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + MetaService_dropHostFromZone_pargs args; + args.get<0>().value = const_cast< ::nebula::meta::cpp2::DropHostFromZoneReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "dropHostFromZone"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void MetaServiceAsyncClient::getZoneT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::GetZoneReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + MetaService_getZone_pargs args; + args.get<0>().value = const_cast< ::nebula::meta::cpp2::GetZoneReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "getZone"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void MetaServiceAsyncClient::listZonesT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::ListZonesReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + MetaService_listZones_pargs args; + args.get<0>().value = const_cast< ::nebula::meta::cpp2::ListZonesReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "listZones"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void MetaServiceAsyncClient::addGroupT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::AddGroupReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + MetaService_addGroup_pargs args; + args.get<0>().value = const_cast< ::nebula::meta::cpp2::AddGroupReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "addGroup"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void MetaServiceAsyncClient::dropGroupT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::DropGroupReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + MetaService_dropGroup_pargs args; + args.get<0>().value = const_cast< ::nebula::meta::cpp2::DropGroupReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "dropGroup"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void MetaServiceAsyncClient::addZoneIntoGroupT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::AddZoneIntoGroupReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + MetaService_addZoneIntoGroup_pargs args; + args.get<0>().value = const_cast< ::nebula::meta::cpp2::AddZoneIntoGroupReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "addZoneIntoGroup"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void MetaServiceAsyncClient::dropZoneFromGroupT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::DropZoneFromGroupReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + MetaService_dropZoneFromGroup_pargs args; + args.get<0>().value = const_cast< ::nebula::meta::cpp2::DropZoneFromGroupReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "dropZoneFromGroup"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void MetaServiceAsyncClient::getGroupT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::GetGroupReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + MetaService_getGroup_pargs args; + args.get<0>().value = const_cast< ::nebula::meta::cpp2::GetGroupReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "getGroup"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void MetaServiceAsyncClient::listGroupsT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::ListGroupsReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + MetaService_listGroups_pargs args; + args.get<0>().value = const_cast< ::nebula::meta::cpp2::ListGroupsReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "listGroups"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void MetaServiceAsyncClient::createBackupT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::CreateBackupReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + MetaService_createBackup_pargs args; + args.get<0>().value = const_cast< ::nebula::meta::cpp2::CreateBackupReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "createBackup"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void MetaServiceAsyncClient::restoreMetaT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::RestoreMetaReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + MetaService_restoreMeta_pargs args; + args.get<0>().value = const_cast< ::nebula::meta::cpp2::RestoreMetaReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "restoreMeta"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void MetaServiceAsyncClient::addListenerT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::AddListenerReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + MetaService_addListener_pargs args; + args.get<0>().value = const_cast< ::nebula::meta::cpp2::AddListenerReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "addListener"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void MetaServiceAsyncClient::removeListenerT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::RemoveListenerReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + MetaService_removeListener_pargs args; + args.get<0>().value = const_cast< ::nebula::meta::cpp2::RemoveListenerReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "removeListener"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void MetaServiceAsyncClient::listListenerT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::ListListenerReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + MetaService_listListener_pargs args; + args.get<0>().value = const_cast< ::nebula::meta::cpp2::ListListenerReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "listListener"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void MetaServiceAsyncClient::getStatsT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::GetStatsReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + MetaService_getStats_pargs args; + args.get<0>().value = const_cast< ::nebula::meta::cpp2::GetStatsReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "getStats"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void MetaServiceAsyncClient::signInFTServiceT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::SignInFTServiceReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + MetaService_signInFTService_pargs args; + args.get<0>().value = const_cast< ::nebula::meta::cpp2::SignInFTServiceReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "signInFTService"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void MetaServiceAsyncClient::signOutFTServiceT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::SignOutFTServiceReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + MetaService_signOutFTService_pargs args; + args.get<0>().value = const_cast< ::nebula::meta::cpp2::SignOutFTServiceReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "signOutFTService"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void MetaServiceAsyncClient::listFTClientsT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::ListFTClientsReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + MetaService_listFTClients_pargs args; + args.get<0>().value = const_cast< ::nebula::meta::cpp2::ListFTClientsReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "listFTClients"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void MetaServiceAsyncClient::createFTIndexT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::CreateFTIndexReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + MetaService_createFTIndex_pargs args; + args.get<0>().value = const_cast< ::nebula::meta::cpp2::CreateFTIndexReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "createFTIndex"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void MetaServiceAsyncClient::dropFTIndexT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::DropFTIndexReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + MetaService_dropFTIndex_pargs args; + args.get<0>().value = const_cast< ::nebula::meta::cpp2::DropFTIndexReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "dropFTIndex"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void MetaServiceAsyncClient::listFTIndexesT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::ListFTIndexesReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + MetaService_listFTIndexes_pargs args; + args.get<0>().value = const_cast< ::nebula::meta::cpp2::ListFTIndexesReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "listFTIndexes"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void MetaServiceAsyncClient::createSessionT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::CreateSessionReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + MetaService_createSession_pargs args; + args.get<0>().value = const_cast< ::nebula::meta::cpp2::CreateSessionReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "createSession"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void MetaServiceAsyncClient::updateSessionsT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::UpdateSessionsReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + MetaService_updateSessions_pargs args; + args.get<0>().value = const_cast< ::nebula::meta::cpp2::UpdateSessionsReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "updateSessions"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void MetaServiceAsyncClient::listSessionsT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::ListSessionsReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + MetaService_listSessions_pargs args; + args.get<0>().value = const_cast< ::nebula::meta::cpp2::ListSessionsReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "listSessions"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void MetaServiceAsyncClient::getSessionT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::GetSessionReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + MetaService_getSession_pargs args; + args.get<0>().value = const_cast< ::nebula::meta::cpp2::GetSessionReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "getSession"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void MetaServiceAsyncClient::removeSessionT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::RemoveSessionReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + MetaService_removeSession_pargs args; + args.get<0>().value = const_cast< ::nebula::meta::cpp2::RemoveSessionReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "removeSession"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void MetaServiceAsyncClient::killQueryT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::KillQueryReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + MetaService_killQuery_pargs args; + args.get<0>().value = const_cast< ::nebula::meta::cpp2::KillQueryReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "killQuery"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void MetaServiceAsyncClient::reportTaskFinishT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::ReportTaskReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + MetaService_reportTaskFinish_pargs args; + args.get<0>().value = const_cast< ::nebula::meta::cpp2::ReportTaskReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "reportTaskFinish"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void MetaServiceAsyncClient::listClusterT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::ListClusterInfoReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + MetaService_listCluster_pargs args; + args.get<0>().value = const_cast< ::nebula::meta::cpp2::ListClusterInfoReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "listCluster"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void MetaServiceAsyncClient::getMetaDirInfoT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::GetMetaDirInfoReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + MetaService_getMetaDirInfo_pargs args; + args.get<0>().value = const_cast< ::nebula::meta::cpp2::GetMetaDirInfoReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "getMetaDirInfo"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void MetaServiceAsyncClient::verifyClientVersionT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::VerifyClientVersionReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + MetaService_verifyClientVersion_pargs args; + args.get<0>().value = const_cast< ::nebula::meta::cpp2::VerifyClientVersionReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "verifyClientVersion"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + + + +void MetaServiceAsyncClient::createSpace(std::unique_ptr callback, const ::nebula::meta::cpp2::CreateSpaceReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + createSpace(rpcOptions, std::move(callback), p_req); +} + +void MetaServiceAsyncClient::createSpace(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::CreateSpaceReq& p_req) { + auto ctx = createSpaceCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + createSpaceImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void MetaServiceAsyncClient::createSpaceImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::CreateSpaceReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + createSpaceT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + createSpaceT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> MetaServiceAsyncClient::createSpaceCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "MetaService.createSpace"); +} + +void MetaServiceAsyncClient::sync_createSpace( ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::CreateSpaceReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_createSpace(rpcOptions, _return, p_req); +} + +void MetaServiceAsyncClient::sync_createSpace(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::CreateSpaceReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = createSpaceCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + createSpaceImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_createSpace(_return, returnState); + }); +} + + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::future_createSpace(const ::nebula::meta::cpp2::CreateSpaceReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_createSpace(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::semifuture_createSpace(const ::nebula::meta::cpp2::CreateSpaceReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_createSpace(rpcOptions, p_req); +} + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::future_createSpace(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateSpaceReq& p_req) { + folly::Promise< ::nebula::meta::cpp2::ExecResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_createSpace, channel_); + createSpace(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::semifuture_createSpace(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateSpaceReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_createSpace, channel_); + auto callback = std::move(callbackAndFuture.first); + createSpace(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> MetaServiceAsyncClient::header_future_createSpace(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateSpaceReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_createSpace, channel_); + createSpace(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> MetaServiceAsyncClient::header_semifuture_createSpace(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateSpaceReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_createSpace, channel_); + auto callback = std::move(callbackAndFuture.first); + createSpace(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void MetaServiceAsyncClient::createSpace(folly::Function callback, const ::nebula::meta::cpp2::CreateSpaceReq& p_req) { + createSpace(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper MetaServiceAsyncClient::recv_wrapped_createSpace( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = MetaService_createSpace_presult; + constexpr auto const fname = "createSpace"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void MetaServiceAsyncClient::recv_createSpace( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_createSpace(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void MetaServiceAsyncClient::recv_instance_createSpace( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_createSpace(_return, state); +} + +folly::exception_wrapper MetaServiceAsyncClient::recv_instance_wrapped_createSpace( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_createSpace(_return, state); +} + +void MetaServiceAsyncClient::dropSpace(std::unique_ptr callback, const ::nebula::meta::cpp2::DropSpaceReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + dropSpace(rpcOptions, std::move(callback), p_req); +} + +void MetaServiceAsyncClient::dropSpace(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::DropSpaceReq& p_req) { + auto ctx = dropSpaceCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + dropSpaceImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void MetaServiceAsyncClient::dropSpaceImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::DropSpaceReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + dropSpaceT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + dropSpaceT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> MetaServiceAsyncClient::dropSpaceCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "MetaService.dropSpace"); +} + +void MetaServiceAsyncClient::sync_dropSpace( ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::DropSpaceReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_dropSpace(rpcOptions, _return, p_req); +} + +void MetaServiceAsyncClient::sync_dropSpace(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::DropSpaceReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = dropSpaceCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + dropSpaceImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_dropSpace(_return, returnState); + }); +} + + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::future_dropSpace(const ::nebula::meta::cpp2::DropSpaceReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_dropSpace(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::semifuture_dropSpace(const ::nebula::meta::cpp2::DropSpaceReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_dropSpace(rpcOptions, p_req); +} + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::future_dropSpace(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropSpaceReq& p_req) { + folly::Promise< ::nebula::meta::cpp2::ExecResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_dropSpace, channel_); + dropSpace(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::semifuture_dropSpace(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropSpaceReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_dropSpace, channel_); + auto callback = std::move(callbackAndFuture.first); + dropSpace(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> MetaServiceAsyncClient::header_future_dropSpace(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropSpaceReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_dropSpace, channel_); + dropSpace(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> MetaServiceAsyncClient::header_semifuture_dropSpace(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropSpaceReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_dropSpace, channel_); + auto callback = std::move(callbackAndFuture.first); + dropSpace(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void MetaServiceAsyncClient::dropSpace(folly::Function callback, const ::nebula::meta::cpp2::DropSpaceReq& p_req) { + dropSpace(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper MetaServiceAsyncClient::recv_wrapped_dropSpace( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = MetaService_dropSpace_presult; + constexpr auto const fname = "dropSpace"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void MetaServiceAsyncClient::recv_dropSpace( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_dropSpace(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void MetaServiceAsyncClient::recv_instance_dropSpace( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_dropSpace(_return, state); +} + +folly::exception_wrapper MetaServiceAsyncClient::recv_instance_wrapped_dropSpace( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_dropSpace(_return, state); +} + +void MetaServiceAsyncClient::getSpace(std::unique_ptr callback, const ::nebula::meta::cpp2::GetSpaceReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + getSpace(rpcOptions, std::move(callback), p_req); +} + +void MetaServiceAsyncClient::getSpace(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::GetSpaceReq& p_req) { + auto ctx = getSpaceCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + getSpaceImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void MetaServiceAsyncClient::getSpaceImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::GetSpaceReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + getSpaceT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + getSpaceT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> MetaServiceAsyncClient::getSpaceCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "MetaService.getSpace"); +} + +void MetaServiceAsyncClient::sync_getSpace( ::nebula::meta::cpp2::GetSpaceResp& _return, const ::nebula::meta::cpp2::GetSpaceReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_getSpace(rpcOptions, _return, p_req); +} + +void MetaServiceAsyncClient::sync_getSpace(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::GetSpaceResp& _return, const ::nebula::meta::cpp2::GetSpaceReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = getSpaceCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + getSpaceImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_getSpace(_return, returnState); + }); +} + + +folly::Future< ::nebula::meta::cpp2::GetSpaceResp> MetaServiceAsyncClient::future_getSpace(const ::nebula::meta::cpp2::GetSpaceReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_getSpace(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::meta::cpp2::GetSpaceResp> MetaServiceAsyncClient::semifuture_getSpace(const ::nebula::meta::cpp2::GetSpaceReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_getSpace(rpcOptions, p_req); +} + +folly::Future< ::nebula::meta::cpp2::GetSpaceResp> MetaServiceAsyncClient::future_getSpace(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetSpaceReq& p_req) { + folly::Promise< ::nebula::meta::cpp2::GetSpaceResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_getSpace, channel_); + getSpace(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::meta::cpp2::GetSpaceResp> MetaServiceAsyncClient::semifuture_getSpace(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetSpaceReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_getSpace, channel_); + auto callback = std::move(callbackAndFuture.first); + getSpace(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> MetaServiceAsyncClient::header_future_getSpace(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetSpaceReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_getSpace, channel_); + getSpace(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> MetaServiceAsyncClient::header_semifuture_getSpace(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetSpaceReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_getSpace, channel_); + auto callback = std::move(callbackAndFuture.first); + getSpace(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void MetaServiceAsyncClient::getSpace(folly::Function callback, const ::nebula::meta::cpp2::GetSpaceReq& p_req) { + getSpace(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper MetaServiceAsyncClient::recv_wrapped_getSpace( ::nebula::meta::cpp2::GetSpaceResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = MetaService_getSpace_presult; + constexpr auto const fname = "getSpace"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void MetaServiceAsyncClient::recv_getSpace( ::nebula::meta::cpp2::GetSpaceResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_getSpace(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void MetaServiceAsyncClient::recv_instance_getSpace( ::nebula::meta::cpp2::GetSpaceResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_getSpace(_return, state); +} + +folly::exception_wrapper MetaServiceAsyncClient::recv_instance_wrapped_getSpace( ::nebula::meta::cpp2::GetSpaceResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_getSpace(_return, state); +} + +void MetaServiceAsyncClient::listSpaces(std::unique_ptr callback, const ::nebula::meta::cpp2::ListSpacesReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + listSpaces(rpcOptions, std::move(callback), p_req); +} + +void MetaServiceAsyncClient::listSpaces(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::ListSpacesReq& p_req) { + auto ctx = listSpacesCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + listSpacesImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void MetaServiceAsyncClient::listSpacesImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::ListSpacesReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + listSpacesT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + listSpacesT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> MetaServiceAsyncClient::listSpacesCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "MetaService.listSpaces"); +} + +void MetaServiceAsyncClient::sync_listSpaces( ::nebula::meta::cpp2::ListSpacesResp& _return, const ::nebula::meta::cpp2::ListSpacesReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_listSpaces(rpcOptions, _return, p_req); +} + +void MetaServiceAsyncClient::sync_listSpaces(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ListSpacesResp& _return, const ::nebula::meta::cpp2::ListSpacesReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = listSpacesCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + listSpacesImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_listSpaces(_return, returnState); + }); +} + + +folly::Future< ::nebula::meta::cpp2::ListSpacesResp> MetaServiceAsyncClient::future_listSpaces(const ::nebula::meta::cpp2::ListSpacesReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_listSpaces(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ListSpacesResp> MetaServiceAsyncClient::semifuture_listSpaces(const ::nebula::meta::cpp2::ListSpacesReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_listSpaces(rpcOptions, p_req); +} + +folly::Future< ::nebula::meta::cpp2::ListSpacesResp> MetaServiceAsyncClient::future_listSpaces(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListSpacesReq& p_req) { + folly::Promise< ::nebula::meta::cpp2::ListSpacesResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_listSpaces, channel_); + listSpaces(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::meta::cpp2::ListSpacesResp> MetaServiceAsyncClient::semifuture_listSpaces(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListSpacesReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_listSpaces, channel_); + auto callback = std::move(callbackAndFuture.first); + listSpaces(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> MetaServiceAsyncClient::header_future_listSpaces(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListSpacesReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_listSpaces, channel_); + listSpaces(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> MetaServiceAsyncClient::header_semifuture_listSpaces(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListSpacesReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_listSpaces, channel_); + auto callback = std::move(callbackAndFuture.first); + listSpaces(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void MetaServiceAsyncClient::listSpaces(folly::Function callback, const ::nebula::meta::cpp2::ListSpacesReq& p_req) { + listSpaces(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper MetaServiceAsyncClient::recv_wrapped_listSpaces( ::nebula::meta::cpp2::ListSpacesResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = MetaService_listSpaces_presult; + constexpr auto const fname = "listSpaces"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void MetaServiceAsyncClient::recv_listSpaces( ::nebula::meta::cpp2::ListSpacesResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_listSpaces(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void MetaServiceAsyncClient::recv_instance_listSpaces( ::nebula::meta::cpp2::ListSpacesResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_listSpaces(_return, state); +} + +folly::exception_wrapper MetaServiceAsyncClient::recv_instance_wrapped_listSpaces( ::nebula::meta::cpp2::ListSpacesResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_listSpaces(_return, state); +} + +void MetaServiceAsyncClient::createSpaceAs(std::unique_ptr callback, const ::nebula::meta::cpp2::CreateSpaceAsReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + createSpaceAs(rpcOptions, std::move(callback), p_req); +} + +void MetaServiceAsyncClient::createSpaceAs(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::CreateSpaceAsReq& p_req) { + auto ctx = createSpaceAsCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + createSpaceAsImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void MetaServiceAsyncClient::createSpaceAsImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::CreateSpaceAsReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + createSpaceAsT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + createSpaceAsT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> MetaServiceAsyncClient::createSpaceAsCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "MetaService.createSpaceAs"); +} + +void MetaServiceAsyncClient::sync_createSpaceAs( ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::CreateSpaceAsReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_createSpaceAs(rpcOptions, _return, p_req); +} + +void MetaServiceAsyncClient::sync_createSpaceAs(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::CreateSpaceAsReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = createSpaceAsCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + createSpaceAsImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_createSpaceAs(_return, returnState); + }); +} + + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::future_createSpaceAs(const ::nebula::meta::cpp2::CreateSpaceAsReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_createSpaceAs(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::semifuture_createSpaceAs(const ::nebula::meta::cpp2::CreateSpaceAsReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_createSpaceAs(rpcOptions, p_req); +} + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::future_createSpaceAs(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateSpaceAsReq& p_req) { + folly::Promise< ::nebula::meta::cpp2::ExecResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_createSpaceAs, channel_); + createSpaceAs(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::semifuture_createSpaceAs(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateSpaceAsReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_createSpaceAs, channel_); + auto callback = std::move(callbackAndFuture.first); + createSpaceAs(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> MetaServiceAsyncClient::header_future_createSpaceAs(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateSpaceAsReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_createSpaceAs, channel_); + createSpaceAs(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> MetaServiceAsyncClient::header_semifuture_createSpaceAs(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateSpaceAsReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_createSpaceAs, channel_); + auto callback = std::move(callbackAndFuture.first); + createSpaceAs(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void MetaServiceAsyncClient::createSpaceAs(folly::Function callback, const ::nebula::meta::cpp2::CreateSpaceAsReq& p_req) { + createSpaceAs(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper MetaServiceAsyncClient::recv_wrapped_createSpaceAs( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = MetaService_createSpaceAs_presult; + constexpr auto const fname = "createSpaceAs"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void MetaServiceAsyncClient::recv_createSpaceAs( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_createSpaceAs(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void MetaServiceAsyncClient::recv_instance_createSpaceAs( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_createSpaceAs(_return, state); +} + +folly::exception_wrapper MetaServiceAsyncClient::recv_instance_wrapped_createSpaceAs( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_createSpaceAs(_return, state); +} + +void MetaServiceAsyncClient::createTag(std::unique_ptr callback, const ::nebula::meta::cpp2::CreateTagReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + createTag(rpcOptions, std::move(callback), p_req); +} + +void MetaServiceAsyncClient::createTag(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::CreateTagReq& p_req) { + auto ctx = createTagCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + createTagImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void MetaServiceAsyncClient::createTagImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::CreateTagReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + createTagT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + createTagT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> MetaServiceAsyncClient::createTagCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "MetaService.createTag"); +} + +void MetaServiceAsyncClient::sync_createTag( ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::CreateTagReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_createTag(rpcOptions, _return, p_req); +} + +void MetaServiceAsyncClient::sync_createTag(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::CreateTagReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = createTagCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + createTagImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_createTag(_return, returnState); + }); +} + + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::future_createTag(const ::nebula::meta::cpp2::CreateTagReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_createTag(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::semifuture_createTag(const ::nebula::meta::cpp2::CreateTagReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_createTag(rpcOptions, p_req); +} + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::future_createTag(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateTagReq& p_req) { + folly::Promise< ::nebula::meta::cpp2::ExecResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_createTag, channel_); + createTag(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::semifuture_createTag(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateTagReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_createTag, channel_); + auto callback = std::move(callbackAndFuture.first); + createTag(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> MetaServiceAsyncClient::header_future_createTag(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateTagReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_createTag, channel_); + createTag(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> MetaServiceAsyncClient::header_semifuture_createTag(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateTagReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_createTag, channel_); + auto callback = std::move(callbackAndFuture.first); + createTag(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void MetaServiceAsyncClient::createTag(folly::Function callback, const ::nebula::meta::cpp2::CreateTagReq& p_req) { + createTag(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper MetaServiceAsyncClient::recv_wrapped_createTag( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = MetaService_createTag_presult; + constexpr auto const fname = "createTag"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void MetaServiceAsyncClient::recv_createTag( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_createTag(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void MetaServiceAsyncClient::recv_instance_createTag( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_createTag(_return, state); +} + +folly::exception_wrapper MetaServiceAsyncClient::recv_instance_wrapped_createTag( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_createTag(_return, state); +} + +void MetaServiceAsyncClient::alterTag(std::unique_ptr callback, const ::nebula::meta::cpp2::AlterTagReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + alterTag(rpcOptions, std::move(callback), p_req); +} + +void MetaServiceAsyncClient::alterTag(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::AlterTagReq& p_req) { + auto ctx = alterTagCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + alterTagImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void MetaServiceAsyncClient::alterTagImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::AlterTagReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + alterTagT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + alterTagT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> MetaServiceAsyncClient::alterTagCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "MetaService.alterTag"); +} + +void MetaServiceAsyncClient::sync_alterTag( ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::AlterTagReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_alterTag(rpcOptions, _return, p_req); +} + +void MetaServiceAsyncClient::sync_alterTag(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::AlterTagReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = alterTagCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + alterTagImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_alterTag(_return, returnState); + }); +} + + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::future_alterTag(const ::nebula::meta::cpp2::AlterTagReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_alterTag(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::semifuture_alterTag(const ::nebula::meta::cpp2::AlterTagReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_alterTag(rpcOptions, p_req); +} + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::future_alterTag(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::AlterTagReq& p_req) { + folly::Promise< ::nebula::meta::cpp2::ExecResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_alterTag, channel_); + alterTag(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::semifuture_alterTag(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::AlterTagReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_alterTag, channel_); + auto callback = std::move(callbackAndFuture.first); + alterTag(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> MetaServiceAsyncClient::header_future_alterTag(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::AlterTagReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_alterTag, channel_); + alterTag(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> MetaServiceAsyncClient::header_semifuture_alterTag(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::AlterTagReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_alterTag, channel_); + auto callback = std::move(callbackAndFuture.first); + alterTag(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void MetaServiceAsyncClient::alterTag(folly::Function callback, const ::nebula::meta::cpp2::AlterTagReq& p_req) { + alterTag(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper MetaServiceAsyncClient::recv_wrapped_alterTag( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = MetaService_alterTag_presult; + constexpr auto const fname = "alterTag"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void MetaServiceAsyncClient::recv_alterTag( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_alterTag(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void MetaServiceAsyncClient::recv_instance_alterTag( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_alterTag(_return, state); +} + +folly::exception_wrapper MetaServiceAsyncClient::recv_instance_wrapped_alterTag( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_alterTag(_return, state); +} + +void MetaServiceAsyncClient::dropTag(std::unique_ptr callback, const ::nebula::meta::cpp2::DropTagReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + dropTag(rpcOptions, std::move(callback), p_req); +} + +void MetaServiceAsyncClient::dropTag(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::DropTagReq& p_req) { + auto ctx = dropTagCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + dropTagImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void MetaServiceAsyncClient::dropTagImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::DropTagReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + dropTagT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + dropTagT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> MetaServiceAsyncClient::dropTagCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "MetaService.dropTag"); +} + +void MetaServiceAsyncClient::sync_dropTag( ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::DropTagReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_dropTag(rpcOptions, _return, p_req); +} + +void MetaServiceAsyncClient::sync_dropTag(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::DropTagReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = dropTagCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + dropTagImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_dropTag(_return, returnState); + }); +} + + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::future_dropTag(const ::nebula::meta::cpp2::DropTagReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_dropTag(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::semifuture_dropTag(const ::nebula::meta::cpp2::DropTagReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_dropTag(rpcOptions, p_req); +} + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::future_dropTag(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropTagReq& p_req) { + folly::Promise< ::nebula::meta::cpp2::ExecResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_dropTag, channel_); + dropTag(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::semifuture_dropTag(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropTagReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_dropTag, channel_); + auto callback = std::move(callbackAndFuture.first); + dropTag(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> MetaServiceAsyncClient::header_future_dropTag(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropTagReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_dropTag, channel_); + dropTag(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> MetaServiceAsyncClient::header_semifuture_dropTag(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropTagReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_dropTag, channel_); + auto callback = std::move(callbackAndFuture.first); + dropTag(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void MetaServiceAsyncClient::dropTag(folly::Function callback, const ::nebula::meta::cpp2::DropTagReq& p_req) { + dropTag(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper MetaServiceAsyncClient::recv_wrapped_dropTag( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = MetaService_dropTag_presult; + constexpr auto const fname = "dropTag"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void MetaServiceAsyncClient::recv_dropTag( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_dropTag(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void MetaServiceAsyncClient::recv_instance_dropTag( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_dropTag(_return, state); +} + +folly::exception_wrapper MetaServiceAsyncClient::recv_instance_wrapped_dropTag( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_dropTag(_return, state); +} + +void MetaServiceAsyncClient::getTag(std::unique_ptr callback, const ::nebula::meta::cpp2::GetTagReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + getTag(rpcOptions, std::move(callback), p_req); +} + +void MetaServiceAsyncClient::getTag(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::GetTagReq& p_req) { + auto ctx = getTagCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + getTagImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void MetaServiceAsyncClient::getTagImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::GetTagReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + getTagT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + getTagT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> MetaServiceAsyncClient::getTagCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "MetaService.getTag"); +} + +void MetaServiceAsyncClient::sync_getTag( ::nebula::meta::cpp2::GetTagResp& _return, const ::nebula::meta::cpp2::GetTagReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_getTag(rpcOptions, _return, p_req); +} + +void MetaServiceAsyncClient::sync_getTag(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::GetTagResp& _return, const ::nebula::meta::cpp2::GetTagReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = getTagCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + getTagImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_getTag(_return, returnState); + }); +} + + +folly::Future< ::nebula::meta::cpp2::GetTagResp> MetaServiceAsyncClient::future_getTag(const ::nebula::meta::cpp2::GetTagReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_getTag(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::meta::cpp2::GetTagResp> MetaServiceAsyncClient::semifuture_getTag(const ::nebula::meta::cpp2::GetTagReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_getTag(rpcOptions, p_req); +} + +folly::Future< ::nebula::meta::cpp2::GetTagResp> MetaServiceAsyncClient::future_getTag(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetTagReq& p_req) { + folly::Promise< ::nebula::meta::cpp2::GetTagResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_getTag, channel_); + getTag(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::meta::cpp2::GetTagResp> MetaServiceAsyncClient::semifuture_getTag(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetTagReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_getTag, channel_); + auto callback = std::move(callbackAndFuture.first); + getTag(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> MetaServiceAsyncClient::header_future_getTag(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetTagReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_getTag, channel_); + getTag(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> MetaServiceAsyncClient::header_semifuture_getTag(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetTagReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_getTag, channel_); + auto callback = std::move(callbackAndFuture.first); + getTag(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void MetaServiceAsyncClient::getTag(folly::Function callback, const ::nebula::meta::cpp2::GetTagReq& p_req) { + getTag(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper MetaServiceAsyncClient::recv_wrapped_getTag( ::nebula::meta::cpp2::GetTagResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = MetaService_getTag_presult; + constexpr auto const fname = "getTag"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void MetaServiceAsyncClient::recv_getTag( ::nebula::meta::cpp2::GetTagResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_getTag(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void MetaServiceAsyncClient::recv_instance_getTag( ::nebula::meta::cpp2::GetTagResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_getTag(_return, state); +} + +folly::exception_wrapper MetaServiceAsyncClient::recv_instance_wrapped_getTag( ::nebula::meta::cpp2::GetTagResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_getTag(_return, state); +} + +void MetaServiceAsyncClient::listTags(std::unique_ptr callback, const ::nebula::meta::cpp2::ListTagsReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + listTags(rpcOptions, std::move(callback), p_req); +} + +void MetaServiceAsyncClient::listTags(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::ListTagsReq& p_req) { + auto ctx = listTagsCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + listTagsImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void MetaServiceAsyncClient::listTagsImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::ListTagsReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + listTagsT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + listTagsT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> MetaServiceAsyncClient::listTagsCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "MetaService.listTags"); +} + +void MetaServiceAsyncClient::sync_listTags( ::nebula::meta::cpp2::ListTagsResp& _return, const ::nebula::meta::cpp2::ListTagsReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_listTags(rpcOptions, _return, p_req); +} + +void MetaServiceAsyncClient::sync_listTags(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ListTagsResp& _return, const ::nebula::meta::cpp2::ListTagsReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = listTagsCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + listTagsImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_listTags(_return, returnState); + }); +} + + +folly::Future< ::nebula::meta::cpp2::ListTagsResp> MetaServiceAsyncClient::future_listTags(const ::nebula::meta::cpp2::ListTagsReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_listTags(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ListTagsResp> MetaServiceAsyncClient::semifuture_listTags(const ::nebula::meta::cpp2::ListTagsReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_listTags(rpcOptions, p_req); +} + +folly::Future< ::nebula::meta::cpp2::ListTagsResp> MetaServiceAsyncClient::future_listTags(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListTagsReq& p_req) { + folly::Promise< ::nebula::meta::cpp2::ListTagsResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_listTags, channel_); + listTags(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::meta::cpp2::ListTagsResp> MetaServiceAsyncClient::semifuture_listTags(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListTagsReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_listTags, channel_); + auto callback = std::move(callbackAndFuture.first); + listTags(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> MetaServiceAsyncClient::header_future_listTags(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListTagsReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_listTags, channel_); + listTags(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> MetaServiceAsyncClient::header_semifuture_listTags(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListTagsReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_listTags, channel_); + auto callback = std::move(callbackAndFuture.first); + listTags(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void MetaServiceAsyncClient::listTags(folly::Function callback, const ::nebula::meta::cpp2::ListTagsReq& p_req) { + listTags(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper MetaServiceAsyncClient::recv_wrapped_listTags( ::nebula::meta::cpp2::ListTagsResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = MetaService_listTags_presult; + constexpr auto const fname = "listTags"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void MetaServiceAsyncClient::recv_listTags( ::nebula::meta::cpp2::ListTagsResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_listTags(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void MetaServiceAsyncClient::recv_instance_listTags( ::nebula::meta::cpp2::ListTagsResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_listTags(_return, state); +} + +folly::exception_wrapper MetaServiceAsyncClient::recv_instance_wrapped_listTags( ::nebula::meta::cpp2::ListTagsResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_listTags(_return, state); +} + +void MetaServiceAsyncClient::createEdge(std::unique_ptr callback, const ::nebula::meta::cpp2::CreateEdgeReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + createEdge(rpcOptions, std::move(callback), p_req); +} + +void MetaServiceAsyncClient::createEdge(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::CreateEdgeReq& p_req) { + auto ctx = createEdgeCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + createEdgeImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void MetaServiceAsyncClient::createEdgeImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::CreateEdgeReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + createEdgeT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + createEdgeT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> MetaServiceAsyncClient::createEdgeCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "MetaService.createEdge"); +} + +void MetaServiceAsyncClient::sync_createEdge( ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::CreateEdgeReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_createEdge(rpcOptions, _return, p_req); +} + +void MetaServiceAsyncClient::sync_createEdge(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::CreateEdgeReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = createEdgeCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + createEdgeImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_createEdge(_return, returnState); + }); +} + + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::future_createEdge(const ::nebula::meta::cpp2::CreateEdgeReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_createEdge(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::semifuture_createEdge(const ::nebula::meta::cpp2::CreateEdgeReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_createEdge(rpcOptions, p_req); +} + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::future_createEdge(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateEdgeReq& p_req) { + folly::Promise< ::nebula::meta::cpp2::ExecResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_createEdge, channel_); + createEdge(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::semifuture_createEdge(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateEdgeReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_createEdge, channel_); + auto callback = std::move(callbackAndFuture.first); + createEdge(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> MetaServiceAsyncClient::header_future_createEdge(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateEdgeReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_createEdge, channel_); + createEdge(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> MetaServiceAsyncClient::header_semifuture_createEdge(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateEdgeReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_createEdge, channel_); + auto callback = std::move(callbackAndFuture.first); + createEdge(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void MetaServiceAsyncClient::createEdge(folly::Function callback, const ::nebula::meta::cpp2::CreateEdgeReq& p_req) { + createEdge(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper MetaServiceAsyncClient::recv_wrapped_createEdge( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = MetaService_createEdge_presult; + constexpr auto const fname = "createEdge"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void MetaServiceAsyncClient::recv_createEdge( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_createEdge(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void MetaServiceAsyncClient::recv_instance_createEdge( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_createEdge(_return, state); +} + +folly::exception_wrapper MetaServiceAsyncClient::recv_instance_wrapped_createEdge( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_createEdge(_return, state); +} + +void MetaServiceAsyncClient::alterEdge(std::unique_ptr callback, const ::nebula::meta::cpp2::AlterEdgeReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + alterEdge(rpcOptions, std::move(callback), p_req); +} + +void MetaServiceAsyncClient::alterEdge(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::AlterEdgeReq& p_req) { + auto ctx = alterEdgeCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + alterEdgeImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void MetaServiceAsyncClient::alterEdgeImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::AlterEdgeReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + alterEdgeT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + alterEdgeT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> MetaServiceAsyncClient::alterEdgeCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "MetaService.alterEdge"); +} + +void MetaServiceAsyncClient::sync_alterEdge( ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::AlterEdgeReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_alterEdge(rpcOptions, _return, p_req); +} + +void MetaServiceAsyncClient::sync_alterEdge(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::AlterEdgeReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = alterEdgeCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + alterEdgeImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_alterEdge(_return, returnState); + }); +} + + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::future_alterEdge(const ::nebula::meta::cpp2::AlterEdgeReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_alterEdge(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::semifuture_alterEdge(const ::nebula::meta::cpp2::AlterEdgeReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_alterEdge(rpcOptions, p_req); +} + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::future_alterEdge(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::AlterEdgeReq& p_req) { + folly::Promise< ::nebula::meta::cpp2::ExecResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_alterEdge, channel_); + alterEdge(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::semifuture_alterEdge(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::AlterEdgeReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_alterEdge, channel_); + auto callback = std::move(callbackAndFuture.first); + alterEdge(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> MetaServiceAsyncClient::header_future_alterEdge(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::AlterEdgeReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_alterEdge, channel_); + alterEdge(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> MetaServiceAsyncClient::header_semifuture_alterEdge(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::AlterEdgeReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_alterEdge, channel_); + auto callback = std::move(callbackAndFuture.first); + alterEdge(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void MetaServiceAsyncClient::alterEdge(folly::Function callback, const ::nebula::meta::cpp2::AlterEdgeReq& p_req) { + alterEdge(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper MetaServiceAsyncClient::recv_wrapped_alterEdge( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = MetaService_alterEdge_presult; + constexpr auto const fname = "alterEdge"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void MetaServiceAsyncClient::recv_alterEdge( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_alterEdge(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void MetaServiceAsyncClient::recv_instance_alterEdge( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_alterEdge(_return, state); +} + +folly::exception_wrapper MetaServiceAsyncClient::recv_instance_wrapped_alterEdge( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_alterEdge(_return, state); +} + +void MetaServiceAsyncClient::dropEdge(std::unique_ptr callback, const ::nebula::meta::cpp2::DropEdgeReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + dropEdge(rpcOptions, std::move(callback), p_req); +} + +void MetaServiceAsyncClient::dropEdge(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::DropEdgeReq& p_req) { + auto ctx = dropEdgeCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + dropEdgeImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void MetaServiceAsyncClient::dropEdgeImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::DropEdgeReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + dropEdgeT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + dropEdgeT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> MetaServiceAsyncClient::dropEdgeCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "MetaService.dropEdge"); +} + +void MetaServiceAsyncClient::sync_dropEdge( ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::DropEdgeReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_dropEdge(rpcOptions, _return, p_req); +} + +void MetaServiceAsyncClient::sync_dropEdge(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::DropEdgeReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = dropEdgeCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + dropEdgeImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_dropEdge(_return, returnState); + }); +} + + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::future_dropEdge(const ::nebula::meta::cpp2::DropEdgeReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_dropEdge(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::semifuture_dropEdge(const ::nebula::meta::cpp2::DropEdgeReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_dropEdge(rpcOptions, p_req); +} + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::future_dropEdge(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropEdgeReq& p_req) { + folly::Promise< ::nebula::meta::cpp2::ExecResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_dropEdge, channel_); + dropEdge(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::semifuture_dropEdge(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropEdgeReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_dropEdge, channel_); + auto callback = std::move(callbackAndFuture.first); + dropEdge(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> MetaServiceAsyncClient::header_future_dropEdge(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropEdgeReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_dropEdge, channel_); + dropEdge(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> MetaServiceAsyncClient::header_semifuture_dropEdge(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropEdgeReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_dropEdge, channel_); + auto callback = std::move(callbackAndFuture.first); + dropEdge(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void MetaServiceAsyncClient::dropEdge(folly::Function callback, const ::nebula::meta::cpp2::DropEdgeReq& p_req) { + dropEdge(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper MetaServiceAsyncClient::recv_wrapped_dropEdge( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = MetaService_dropEdge_presult; + constexpr auto const fname = "dropEdge"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void MetaServiceAsyncClient::recv_dropEdge( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_dropEdge(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void MetaServiceAsyncClient::recv_instance_dropEdge( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_dropEdge(_return, state); +} + +folly::exception_wrapper MetaServiceAsyncClient::recv_instance_wrapped_dropEdge( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_dropEdge(_return, state); +} + +void MetaServiceAsyncClient::getEdge(std::unique_ptr callback, const ::nebula::meta::cpp2::GetEdgeReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + getEdge(rpcOptions, std::move(callback), p_req); +} + +void MetaServiceAsyncClient::getEdge(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::GetEdgeReq& p_req) { + auto ctx = getEdgeCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + getEdgeImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void MetaServiceAsyncClient::getEdgeImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::GetEdgeReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + getEdgeT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + getEdgeT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> MetaServiceAsyncClient::getEdgeCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "MetaService.getEdge"); +} + +void MetaServiceAsyncClient::sync_getEdge( ::nebula::meta::cpp2::GetEdgeResp& _return, const ::nebula::meta::cpp2::GetEdgeReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_getEdge(rpcOptions, _return, p_req); +} + +void MetaServiceAsyncClient::sync_getEdge(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::GetEdgeResp& _return, const ::nebula::meta::cpp2::GetEdgeReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = getEdgeCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + getEdgeImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_getEdge(_return, returnState); + }); +} + + +folly::Future< ::nebula::meta::cpp2::GetEdgeResp> MetaServiceAsyncClient::future_getEdge(const ::nebula::meta::cpp2::GetEdgeReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_getEdge(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::meta::cpp2::GetEdgeResp> MetaServiceAsyncClient::semifuture_getEdge(const ::nebula::meta::cpp2::GetEdgeReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_getEdge(rpcOptions, p_req); +} + +folly::Future< ::nebula::meta::cpp2::GetEdgeResp> MetaServiceAsyncClient::future_getEdge(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetEdgeReq& p_req) { + folly::Promise< ::nebula::meta::cpp2::GetEdgeResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_getEdge, channel_); + getEdge(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::meta::cpp2::GetEdgeResp> MetaServiceAsyncClient::semifuture_getEdge(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetEdgeReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_getEdge, channel_); + auto callback = std::move(callbackAndFuture.first); + getEdge(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> MetaServiceAsyncClient::header_future_getEdge(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetEdgeReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_getEdge, channel_); + getEdge(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> MetaServiceAsyncClient::header_semifuture_getEdge(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetEdgeReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_getEdge, channel_); + auto callback = std::move(callbackAndFuture.first); + getEdge(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void MetaServiceAsyncClient::getEdge(folly::Function callback, const ::nebula::meta::cpp2::GetEdgeReq& p_req) { + getEdge(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper MetaServiceAsyncClient::recv_wrapped_getEdge( ::nebula::meta::cpp2::GetEdgeResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = MetaService_getEdge_presult; + constexpr auto const fname = "getEdge"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void MetaServiceAsyncClient::recv_getEdge( ::nebula::meta::cpp2::GetEdgeResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_getEdge(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void MetaServiceAsyncClient::recv_instance_getEdge( ::nebula::meta::cpp2::GetEdgeResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_getEdge(_return, state); +} + +folly::exception_wrapper MetaServiceAsyncClient::recv_instance_wrapped_getEdge( ::nebula::meta::cpp2::GetEdgeResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_getEdge(_return, state); +} + +void MetaServiceAsyncClient::listEdges(std::unique_ptr callback, const ::nebula::meta::cpp2::ListEdgesReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + listEdges(rpcOptions, std::move(callback), p_req); +} + +void MetaServiceAsyncClient::listEdges(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::ListEdgesReq& p_req) { + auto ctx = listEdgesCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + listEdgesImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void MetaServiceAsyncClient::listEdgesImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::ListEdgesReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + listEdgesT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + listEdgesT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> MetaServiceAsyncClient::listEdgesCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "MetaService.listEdges"); +} + +void MetaServiceAsyncClient::sync_listEdges( ::nebula::meta::cpp2::ListEdgesResp& _return, const ::nebula::meta::cpp2::ListEdgesReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_listEdges(rpcOptions, _return, p_req); +} + +void MetaServiceAsyncClient::sync_listEdges(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ListEdgesResp& _return, const ::nebula::meta::cpp2::ListEdgesReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = listEdgesCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + listEdgesImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_listEdges(_return, returnState); + }); +} + + +folly::Future< ::nebula::meta::cpp2::ListEdgesResp> MetaServiceAsyncClient::future_listEdges(const ::nebula::meta::cpp2::ListEdgesReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_listEdges(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ListEdgesResp> MetaServiceAsyncClient::semifuture_listEdges(const ::nebula::meta::cpp2::ListEdgesReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_listEdges(rpcOptions, p_req); +} + +folly::Future< ::nebula::meta::cpp2::ListEdgesResp> MetaServiceAsyncClient::future_listEdges(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListEdgesReq& p_req) { + folly::Promise< ::nebula::meta::cpp2::ListEdgesResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_listEdges, channel_); + listEdges(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::meta::cpp2::ListEdgesResp> MetaServiceAsyncClient::semifuture_listEdges(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListEdgesReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_listEdges, channel_); + auto callback = std::move(callbackAndFuture.first); + listEdges(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> MetaServiceAsyncClient::header_future_listEdges(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListEdgesReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_listEdges, channel_); + listEdges(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> MetaServiceAsyncClient::header_semifuture_listEdges(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListEdgesReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_listEdges, channel_); + auto callback = std::move(callbackAndFuture.first); + listEdges(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void MetaServiceAsyncClient::listEdges(folly::Function callback, const ::nebula::meta::cpp2::ListEdgesReq& p_req) { + listEdges(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper MetaServiceAsyncClient::recv_wrapped_listEdges( ::nebula::meta::cpp2::ListEdgesResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = MetaService_listEdges_presult; + constexpr auto const fname = "listEdges"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void MetaServiceAsyncClient::recv_listEdges( ::nebula::meta::cpp2::ListEdgesResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_listEdges(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void MetaServiceAsyncClient::recv_instance_listEdges( ::nebula::meta::cpp2::ListEdgesResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_listEdges(_return, state); +} + +folly::exception_wrapper MetaServiceAsyncClient::recv_instance_wrapped_listEdges( ::nebula::meta::cpp2::ListEdgesResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_listEdges(_return, state); +} + +void MetaServiceAsyncClient::listHosts(std::unique_ptr callback, const ::nebula::meta::cpp2::ListHostsReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + listHosts(rpcOptions, std::move(callback), p_req); +} + +void MetaServiceAsyncClient::listHosts(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::ListHostsReq& p_req) { + auto ctx = listHostsCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + listHostsImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void MetaServiceAsyncClient::listHostsImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::ListHostsReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + listHostsT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + listHostsT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> MetaServiceAsyncClient::listHostsCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "MetaService.listHosts"); +} + +void MetaServiceAsyncClient::sync_listHosts( ::nebula::meta::cpp2::ListHostsResp& _return, const ::nebula::meta::cpp2::ListHostsReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_listHosts(rpcOptions, _return, p_req); +} + +void MetaServiceAsyncClient::sync_listHosts(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ListHostsResp& _return, const ::nebula::meta::cpp2::ListHostsReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = listHostsCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + listHostsImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_listHosts(_return, returnState); + }); +} + + +folly::Future< ::nebula::meta::cpp2::ListHostsResp> MetaServiceAsyncClient::future_listHosts(const ::nebula::meta::cpp2::ListHostsReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_listHosts(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ListHostsResp> MetaServiceAsyncClient::semifuture_listHosts(const ::nebula::meta::cpp2::ListHostsReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_listHosts(rpcOptions, p_req); +} + +folly::Future< ::nebula::meta::cpp2::ListHostsResp> MetaServiceAsyncClient::future_listHosts(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListHostsReq& p_req) { + folly::Promise< ::nebula::meta::cpp2::ListHostsResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_listHosts, channel_); + listHosts(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::meta::cpp2::ListHostsResp> MetaServiceAsyncClient::semifuture_listHosts(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListHostsReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_listHosts, channel_); + auto callback = std::move(callbackAndFuture.first); + listHosts(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> MetaServiceAsyncClient::header_future_listHosts(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListHostsReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_listHosts, channel_); + listHosts(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> MetaServiceAsyncClient::header_semifuture_listHosts(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListHostsReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_listHosts, channel_); + auto callback = std::move(callbackAndFuture.first); + listHosts(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void MetaServiceAsyncClient::listHosts(folly::Function callback, const ::nebula::meta::cpp2::ListHostsReq& p_req) { + listHosts(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper MetaServiceAsyncClient::recv_wrapped_listHosts( ::nebula::meta::cpp2::ListHostsResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = MetaService_listHosts_presult; + constexpr auto const fname = "listHosts"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void MetaServiceAsyncClient::recv_listHosts( ::nebula::meta::cpp2::ListHostsResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_listHosts(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void MetaServiceAsyncClient::recv_instance_listHosts( ::nebula::meta::cpp2::ListHostsResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_listHosts(_return, state); +} + +folly::exception_wrapper MetaServiceAsyncClient::recv_instance_wrapped_listHosts( ::nebula::meta::cpp2::ListHostsResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_listHosts(_return, state); +} + +void MetaServiceAsyncClient::getPartsAlloc(std::unique_ptr callback, const ::nebula::meta::cpp2::GetPartsAllocReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + getPartsAlloc(rpcOptions, std::move(callback), p_req); +} + +void MetaServiceAsyncClient::getPartsAlloc(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::GetPartsAllocReq& p_req) { + auto ctx = getPartsAllocCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + getPartsAllocImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void MetaServiceAsyncClient::getPartsAllocImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::GetPartsAllocReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + getPartsAllocT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + getPartsAllocT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> MetaServiceAsyncClient::getPartsAllocCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "MetaService.getPartsAlloc"); +} + +void MetaServiceAsyncClient::sync_getPartsAlloc( ::nebula::meta::cpp2::GetPartsAllocResp& _return, const ::nebula::meta::cpp2::GetPartsAllocReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_getPartsAlloc(rpcOptions, _return, p_req); +} + +void MetaServiceAsyncClient::sync_getPartsAlloc(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::GetPartsAllocResp& _return, const ::nebula::meta::cpp2::GetPartsAllocReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = getPartsAllocCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + getPartsAllocImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_getPartsAlloc(_return, returnState); + }); +} + + +folly::Future< ::nebula::meta::cpp2::GetPartsAllocResp> MetaServiceAsyncClient::future_getPartsAlloc(const ::nebula::meta::cpp2::GetPartsAllocReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_getPartsAlloc(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::meta::cpp2::GetPartsAllocResp> MetaServiceAsyncClient::semifuture_getPartsAlloc(const ::nebula::meta::cpp2::GetPartsAllocReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_getPartsAlloc(rpcOptions, p_req); +} + +folly::Future< ::nebula::meta::cpp2::GetPartsAllocResp> MetaServiceAsyncClient::future_getPartsAlloc(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetPartsAllocReq& p_req) { + folly::Promise< ::nebula::meta::cpp2::GetPartsAllocResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_getPartsAlloc, channel_); + getPartsAlloc(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::meta::cpp2::GetPartsAllocResp> MetaServiceAsyncClient::semifuture_getPartsAlloc(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetPartsAllocReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_getPartsAlloc, channel_); + auto callback = std::move(callbackAndFuture.first); + getPartsAlloc(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> MetaServiceAsyncClient::header_future_getPartsAlloc(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetPartsAllocReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_getPartsAlloc, channel_); + getPartsAlloc(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> MetaServiceAsyncClient::header_semifuture_getPartsAlloc(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetPartsAllocReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_getPartsAlloc, channel_); + auto callback = std::move(callbackAndFuture.first); + getPartsAlloc(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void MetaServiceAsyncClient::getPartsAlloc(folly::Function callback, const ::nebula::meta::cpp2::GetPartsAllocReq& p_req) { + getPartsAlloc(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper MetaServiceAsyncClient::recv_wrapped_getPartsAlloc( ::nebula::meta::cpp2::GetPartsAllocResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = MetaService_getPartsAlloc_presult; + constexpr auto const fname = "getPartsAlloc"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void MetaServiceAsyncClient::recv_getPartsAlloc( ::nebula::meta::cpp2::GetPartsAllocResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_getPartsAlloc(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void MetaServiceAsyncClient::recv_instance_getPartsAlloc( ::nebula::meta::cpp2::GetPartsAllocResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_getPartsAlloc(_return, state); +} + +folly::exception_wrapper MetaServiceAsyncClient::recv_instance_wrapped_getPartsAlloc( ::nebula::meta::cpp2::GetPartsAllocResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_getPartsAlloc(_return, state); +} + +void MetaServiceAsyncClient::listParts(std::unique_ptr callback, const ::nebula::meta::cpp2::ListPartsReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + listParts(rpcOptions, std::move(callback), p_req); +} + +void MetaServiceAsyncClient::listParts(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::ListPartsReq& p_req) { + auto ctx = listPartsCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + listPartsImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void MetaServiceAsyncClient::listPartsImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::ListPartsReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + listPartsT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + listPartsT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> MetaServiceAsyncClient::listPartsCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "MetaService.listParts"); +} + +void MetaServiceAsyncClient::sync_listParts( ::nebula::meta::cpp2::ListPartsResp& _return, const ::nebula::meta::cpp2::ListPartsReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_listParts(rpcOptions, _return, p_req); +} + +void MetaServiceAsyncClient::sync_listParts(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ListPartsResp& _return, const ::nebula::meta::cpp2::ListPartsReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = listPartsCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + listPartsImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_listParts(_return, returnState); + }); +} + + +folly::Future< ::nebula::meta::cpp2::ListPartsResp> MetaServiceAsyncClient::future_listParts(const ::nebula::meta::cpp2::ListPartsReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_listParts(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ListPartsResp> MetaServiceAsyncClient::semifuture_listParts(const ::nebula::meta::cpp2::ListPartsReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_listParts(rpcOptions, p_req); +} + +folly::Future< ::nebula::meta::cpp2::ListPartsResp> MetaServiceAsyncClient::future_listParts(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListPartsReq& p_req) { + folly::Promise< ::nebula::meta::cpp2::ListPartsResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_listParts, channel_); + listParts(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::meta::cpp2::ListPartsResp> MetaServiceAsyncClient::semifuture_listParts(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListPartsReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_listParts, channel_); + auto callback = std::move(callbackAndFuture.first); + listParts(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> MetaServiceAsyncClient::header_future_listParts(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListPartsReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_listParts, channel_); + listParts(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> MetaServiceAsyncClient::header_semifuture_listParts(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListPartsReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_listParts, channel_); + auto callback = std::move(callbackAndFuture.first); + listParts(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void MetaServiceAsyncClient::listParts(folly::Function callback, const ::nebula::meta::cpp2::ListPartsReq& p_req) { + listParts(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper MetaServiceAsyncClient::recv_wrapped_listParts( ::nebula::meta::cpp2::ListPartsResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = MetaService_listParts_presult; + constexpr auto const fname = "listParts"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void MetaServiceAsyncClient::recv_listParts( ::nebula::meta::cpp2::ListPartsResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_listParts(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void MetaServiceAsyncClient::recv_instance_listParts( ::nebula::meta::cpp2::ListPartsResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_listParts(_return, state); +} + +folly::exception_wrapper MetaServiceAsyncClient::recv_instance_wrapped_listParts( ::nebula::meta::cpp2::ListPartsResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_listParts(_return, state); +} + +void MetaServiceAsyncClient::multiPut(std::unique_ptr callback, const ::nebula::meta::cpp2::MultiPutReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + multiPut(rpcOptions, std::move(callback), p_req); +} + +void MetaServiceAsyncClient::multiPut(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::MultiPutReq& p_req) { + auto ctx = multiPutCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + multiPutImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void MetaServiceAsyncClient::multiPutImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::MultiPutReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + multiPutT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + multiPutT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> MetaServiceAsyncClient::multiPutCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "MetaService.multiPut"); +} + +void MetaServiceAsyncClient::sync_multiPut( ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::MultiPutReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_multiPut(rpcOptions, _return, p_req); +} + +void MetaServiceAsyncClient::sync_multiPut(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::MultiPutReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = multiPutCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + multiPutImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_multiPut(_return, returnState); + }); +} + + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::future_multiPut(const ::nebula::meta::cpp2::MultiPutReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_multiPut(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::semifuture_multiPut(const ::nebula::meta::cpp2::MultiPutReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_multiPut(rpcOptions, p_req); +} + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::future_multiPut(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::MultiPutReq& p_req) { + folly::Promise< ::nebula::meta::cpp2::ExecResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_multiPut, channel_); + multiPut(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::semifuture_multiPut(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::MultiPutReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_multiPut, channel_); + auto callback = std::move(callbackAndFuture.first); + multiPut(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> MetaServiceAsyncClient::header_future_multiPut(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::MultiPutReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_multiPut, channel_); + multiPut(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> MetaServiceAsyncClient::header_semifuture_multiPut(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::MultiPutReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_multiPut, channel_); + auto callback = std::move(callbackAndFuture.first); + multiPut(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void MetaServiceAsyncClient::multiPut(folly::Function callback, const ::nebula::meta::cpp2::MultiPutReq& p_req) { + multiPut(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper MetaServiceAsyncClient::recv_wrapped_multiPut( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = MetaService_multiPut_presult; + constexpr auto const fname = "multiPut"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void MetaServiceAsyncClient::recv_multiPut( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_multiPut(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void MetaServiceAsyncClient::recv_instance_multiPut( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_multiPut(_return, state); +} + +folly::exception_wrapper MetaServiceAsyncClient::recv_instance_wrapped_multiPut( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_multiPut(_return, state); +} + +void MetaServiceAsyncClient::get(std::unique_ptr callback, const ::nebula::meta::cpp2::GetReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + get(rpcOptions, std::move(callback), p_req); +} + +void MetaServiceAsyncClient::get(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::GetReq& p_req) { + auto ctx = getCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + getImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void MetaServiceAsyncClient::getImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::GetReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + getT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + getT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> MetaServiceAsyncClient::getCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "MetaService.get"); +} + +void MetaServiceAsyncClient::sync_get( ::nebula::meta::cpp2::GetResp& _return, const ::nebula::meta::cpp2::GetReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_get(rpcOptions, _return, p_req); +} + +void MetaServiceAsyncClient::sync_get(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::GetResp& _return, const ::nebula::meta::cpp2::GetReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = getCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + getImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_get(_return, returnState); + }); +} + + +folly::Future< ::nebula::meta::cpp2::GetResp> MetaServiceAsyncClient::future_get(const ::nebula::meta::cpp2::GetReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_get(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::meta::cpp2::GetResp> MetaServiceAsyncClient::semifuture_get(const ::nebula::meta::cpp2::GetReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_get(rpcOptions, p_req); +} + +folly::Future< ::nebula::meta::cpp2::GetResp> MetaServiceAsyncClient::future_get(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetReq& p_req) { + folly::Promise< ::nebula::meta::cpp2::GetResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_get, channel_); + get(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::meta::cpp2::GetResp> MetaServiceAsyncClient::semifuture_get(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_get, channel_); + auto callback = std::move(callbackAndFuture.first); + get(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> MetaServiceAsyncClient::header_future_get(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_get, channel_); + get(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> MetaServiceAsyncClient::header_semifuture_get(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_get, channel_); + auto callback = std::move(callbackAndFuture.first); + get(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void MetaServiceAsyncClient::get(folly::Function callback, const ::nebula::meta::cpp2::GetReq& p_req) { + get(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper MetaServiceAsyncClient::recv_wrapped_get( ::nebula::meta::cpp2::GetResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = MetaService_get_presult; + constexpr auto const fname = "get"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void MetaServiceAsyncClient::recv_get( ::nebula::meta::cpp2::GetResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_get(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void MetaServiceAsyncClient::recv_instance_get( ::nebula::meta::cpp2::GetResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_get(_return, state); +} + +folly::exception_wrapper MetaServiceAsyncClient::recv_instance_wrapped_get( ::nebula::meta::cpp2::GetResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_get(_return, state); +} + +void MetaServiceAsyncClient::multiGet(std::unique_ptr callback, const ::nebula::meta::cpp2::MultiGetReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + multiGet(rpcOptions, std::move(callback), p_req); +} + +void MetaServiceAsyncClient::multiGet(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::MultiGetReq& p_req) { + auto ctx = multiGetCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + multiGetImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void MetaServiceAsyncClient::multiGetImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::MultiGetReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + multiGetT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + multiGetT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> MetaServiceAsyncClient::multiGetCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "MetaService.multiGet"); +} + +void MetaServiceAsyncClient::sync_multiGet( ::nebula::meta::cpp2::MultiGetResp& _return, const ::nebula::meta::cpp2::MultiGetReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_multiGet(rpcOptions, _return, p_req); +} + +void MetaServiceAsyncClient::sync_multiGet(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::MultiGetResp& _return, const ::nebula::meta::cpp2::MultiGetReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = multiGetCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + multiGetImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_multiGet(_return, returnState); + }); +} + + +folly::Future< ::nebula::meta::cpp2::MultiGetResp> MetaServiceAsyncClient::future_multiGet(const ::nebula::meta::cpp2::MultiGetReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_multiGet(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::meta::cpp2::MultiGetResp> MetaServiceAsyncClient::semifuture_multiGet(const ::nebula::meta::cpp2::MultiGetReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_multiGet(rpcOptions, p_req); +} + +folly::Future< ::nebula::meta::cpp2::MultiGetResp> MetaServiceAsyncClient::future_multiGet(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::MultiGetReq& p_req) { + folly::Promise< ::nebula::meta::cpp2::MultiGetResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_multiGet, channel_); + multiGet(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::meta::cpp2::MultiGetResp> MetaServiceAsyncClient::semifuture_multiGet(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::MultiGetReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_multiGet, channel_); + auto callback = std::move(callbackAndFuture.first); + multiGet(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> MetaServiceAsyncClient::header_future_multiGet(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::MultiGetReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_multiGet, channel_); + multiGet(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> MetaServiceAsyncClient::header_semifuture_multiGet(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::MultiGetReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_multiGet, channel_); + auto callback = std::move(callbackAndFuture.first); + multiGet(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void MetaServiceAsyncClient::multiGet(folly::Function callback, const ::nebula::meta::cpp2::MultiGetReq& p_req) { + multiGet(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper MetaServiceAsyncClient::recv_wrapped_multiGet( ::nebula::meta::cpp2::MultiGetResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = MetaService_multiGet_presult; + constexpr auto const fname = "multiGet"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void MetaServiceAsyncClient::recv_multiGet( ::nebula::meta::cpp2::MultiGetResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_multiGet(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void MetaServiceAsyncClient::recv_instance_multiGet( ::nebula::meta::cpp2::MultiGetResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_multiGet(_return, state); +} + +folly::exception_wrapper MetaServiceAsyncClient::recv_instance_wrapped_multiGet( ::nebula::meta::cpp2::MultiGetResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_multiGet(_return, state); +} + +void MetaServiceAsyncClient::remove(std::unique_ptr callback, const ::nebula::meta::cpp2::RemoveReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + remove(rpcOptions, std::move(callback), p_req); +} + +void MetaServiceAsyncClient::remove(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::RemoveReq& p_req) { + auto ctx = removeCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + removeImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void MetaServiceAsyncClient::removeImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::RemoveReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + removeT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + removeT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> MetaServiceAsyncClient::removeCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "MetaService.remove"); +} + +void MetaServiceAsyncClient::sync_remove( ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::RemoveReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_remove(rpcOptions, _return, p_req); +} + +void MetaServiceAsyncClient::sync_remove(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::RemoveReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = removeCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + removeImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_remove(_return, returnState); + }); +} + + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::future_remove(const ::nebula::meta::cpp2::RemoveReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_remove(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::semifuture_remove(const ::nebula::meta::cpp2::RemoveReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_remove(rpcOptions, p_req); +} + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::future_remove(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::RemoveReq& p_req) { + folly::Promise< ::nebula::meta::cpp2::ExecResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_remove, channel_); + remove(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::semifuture_remove(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::RemoveReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_remove, channel_); + auto callback = std::move(callbackAndFuture.first); + remove(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> MetaServiceAsyncClient::header_future_remove(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::RemoveReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_remove, channel_); + remove(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> MetaServiceAsyncClient::header_semifuture_remove(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::RemoveReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_remove, channel_); + auto callback = std::move(callbackAndFuture.first); + remove(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void MetaServiceAsyncClient::remove(folly::Function callback, const ::nebula::meta::cpp2::RemoveReq& p_req) { + remove(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper MetaServiceAsyncClient::recv_wrapped_remove( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = MetaService_remove_presult; + constexpr auto const fname = "remove"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void MetaServiceAsyncClient::recv_remove( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_remove(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void MetaServiceAsyncClient::recv_instance_remove( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_remove(_return, state); +} + +folly::exception_wrapper MetaServiceAsyncClient::recv_instance_wrapped_remove( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_remove(_return, state); +} + +void MetaServiceAsyncClient::removeRange(std::unique_ptr callback, const ::nebula::meta::cpp2::RemoveRangeReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + removeRange(rpcOptions, std::move(callback), p_req); +} + +void MetaServiceAsyncClient::removeRange(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::RemoveRangeReq& p_req) { + auto ctx = removeRangeCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + removeRangeImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void MetaServiceAsyncClient::removeRangeImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::RemoveRangeReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + removeRangeT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + removeRangeT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> MetaServiceAsyncClient::removeRangeCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "MetaService.removeRange"); +} + +void MetaServiceAsyncClient::sync_removeRange( ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::RemoveRangeReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_removeRange(rpcOptions, _return, p_req); +} + +void MetaServiceAsyncClient::sync_removeRange(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::RemoveRangeReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = removeRangeCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + removeRangeImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_removeRange(_return, returnState); + }); +} + + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::future_removeRange(const ::nebula::meta::cpp2::RemoveRangeReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_removeRange(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::semifuture_removeRange(const ::nebula::meta::cpp2::RemoveRangeReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_removeRange(rpcOptions, p_req); +} + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::future_removeRange(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::RemoveRangeReq& p_req) { + folly::Promise< ::nebula::meta::cpp2::ExecResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_removeRange, channel_); + removeRange(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::semifuture_removeRange(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::RemoveRangeReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_removeRange, channel_); + auto callback = std::move(callbackAndFuture.first); + removeRange(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> MetaServiceAsyncClient::header_future_removeRange(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::RemoveRangeReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_removeRange, channel_); + removeRange(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> MetaServiceAsyncClient::header_semifuture_removeRange(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::RemoveRangeReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_removeRange, channel_); + auto callback = std::move(callbackAndFuture.first); + removeRange(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void MetaServiceAsyncClient::removeRange(folly::Function callback, const ::nebula::meta::cpp2::RemoveRangeReq& p_req) { + removeRange(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper MetaServiceAsyncClient::recv_wrapped_removeRange( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = MetaService_removeRange_presult; + constexpr auto const fname = "removeRange"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void MetaServiceAsyncClient::recv_removeRange( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_removeRange(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void MetaServiceAsyncClient::recv_instance_removeRange( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_removeRange(_return, state); +} + +folly::exception_wrapper MetaServiceAsyncClient::recv_instance_wrapped_removeRange( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_removeRange(_return, state); +} + +void MetaServiceAsyncClient::scan(std::unique_ptr callback, const ::nebula::meta::cpp2::ScanReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + scan(rpcOptions, std::move(callback), p_req); +} + +void MetaServiceAsyncClient::scan(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::ScanReq& p_req) { + auto ctx = scanCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + scanImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void MetaServiceAsyncClient::scanImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::ScanReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + scanT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + scanT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> MetaServiceAsyncClient::scanCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "MetaService.scan"); +} + +void MetaServiceAsyncClient::sync_scan( ::nebula::meta::cpp2::ScanResp& _return, const ::nebula::meta::cpp2::ScanReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_scan(rpcOptions, _return, p_req); +} + +void MetaServiceAsyncClient::sync_scan(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ScanResp& _return, const ::nebula::meta::cpp2::ScanReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = scanCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + scanImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_scan(_return, returnState); + }); +} + + +folly::Future< ::nebula::meta::cpp2::ScanResp> MetaServiceAsyncClient::future_scan(const ::nebula::meta::cpp2::ScanReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_scan(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ScanResp> MetaServiceAsyncClient::semifuture_scan(const ::nebula::meta::cpp2::ScanReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_scan(rpcOptions, p_req); +} + +folly::Future< ::nebula::meta::cpp2::ScanResp> MetaServiceAsyncClient::future_scan(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ScanReq& p_req) { + folly::Promise< ::nebula::meta::cpp2::ScanResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_scan, channel_); + scan(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::meta::cpp2::ScanResp> MetaServiceAsyncClient::semifuture_scan(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ScanReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_scan, channel_); + auto callback = std::move(callbackAndFuture.first); + scan(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> MetaServiceAsyncClient::header_future_scan(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ScanReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_scan, channel_); + scan(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> MetaServiceAsyncClient::header_semifuture_scan(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ScanReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_scan, channel_); + auto callback = std::move(callbackAndFuture.first); + scan(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void MetaServiceAsyncClient::scan(folly::Function callback, const ::nebula::meta::cpp2::ScanReq& p_req) { + scan(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper MetaServiceAsyncClient::recv_wrapped_scan( ::nebula::meta::cpp2::ScanResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = MetaService_scan_presult; + constexpr auto const fname = "scan"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void MetaServiceAsyncClient::recv_scan( ::nebula::meta::cpp2::ScanResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_scan(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void MetaServiceAsyncClient::recv_instance_scan( ::nebula::meta::cpp2::ScanResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_scan(_return, state); +} + +folly::exception_wrapper MetaServiceAsyncClient::recv_instance_wrapped_scan( ::nebula::meta::cpp2::ScanResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_scan(_return, state); +} + +void MetaServiceAsyncClient::createTagIndex(std::unique_ptr callback, const ::nebula::meta::cpp2::CreateTagIndexReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + createTagIndex(rpcOptions, std::move(callback), p_req); +} + +void MetaServiceAsyncClient::createTagIndex(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::CreateTagIndexReq& p_req) { + auto ctx = createTagIndexCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + createTagIndexImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void MetaServiceAsyncClient::createTagIndexImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::CreateTagIndexReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + createTagIndexT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + createTagIndexT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> MetaServiceAsyncClient::createTagIndexCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "MetaService.createTagIndex"); +} + +void MetaServiceAsyncClient::sync_createTagIndex( ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::CreateTagIndexReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_createTagIndex(rpcOptions, _return, p_req); +} + +void MetaServiceAsyncClient::sync_createTagIndex(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::CreateTagIndexReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = createTagIndexCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + createTagIndexImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_createTagIndex(_return, returnState); + }); +} + + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::future_createTagIndex(const ::nebula::meta::cpp2::CreateTagIndexReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_createTagIndex(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::semifuture_createTagIndex(const ::nebula::meta::cpp2::CreateTagIndexReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_createTagIndex(rpcOptions, p_req); +} + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::future_createTagIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateTagIndexReq& p_req) { + folly::Promise< ::nebula::meta::cpp2::ExecResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_createTagIndex, channel_); + createTagIndex(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::semifuture_createTagIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateTagIndexReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_createTagIndex, channel_); + auto callback = std::move(callbackAndFuture.first); + createTagIndex(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> MetaServiceAsyncClient::header_future_createTagIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateTagIndexReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_createTagIndex, channel_); + createTagIndex(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> MetaServiceAsyncClient::header_semifuture_createTagIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateTagIndexReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_createTagIndex, channel_); + auto callback = std::move(callbackAndFuture.first); + createTagIndex(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void MetaServiceAsyncClient::createTagIndex(folly::Function callback, const ::nebula::meta::cpp2::CreateTagIndexReq& p_req) { + createTagIndex(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper MetaServiceAsyncClient::recv_wrapped_createTagIndex( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = MetaService_createTagIndex_presult; + constexpr auto const fname = "createTagIndex"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void MetaServiceAsyncClient::recv_createTagIndex( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_createTagIndex(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void MetaServiceAsyncClient::recv_instance_createTagIndex( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_createTagIndex(_return, state); +} + +folly::exception_wrapper MetaServiceAsyncClient::recv_instance_wrapped_createTagIndex( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_createTagIndex(_return, state); +} + +void MetaServiceAsyncClient::dropTagIndex(std::unique_ptr callback, const ::nebula::meta::cpp2::DropTagIndexReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + dropTagIndex(rpcOptions, std::move(callback), p_req); +} + +void MetaServiceAsyncClient::dropTagIndex(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::DropTagIndexReq& p_req) { + auto ctx = dropTagIndexCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + dropTagIndexImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void MetaServiceAsyncClient::dropTagIndexImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::DropTagIndexReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + dropTagIndexT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + dropTagIndexT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> MetaServiceAsyncClient::dropTagIndexCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "MetaService.dropTagIndex"); +} + +void MetaServiceAsyncClient::sync_dropTagIndex( ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::DropTagIndexReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_dropTagIndex(rpcOptions, _return, p_req); +} + +void MetaServiceAsyncClient::sync_dropTagIndex(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::DropTagIndexReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = dropTagIndexCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + dropTagIndexImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_dropTagIndex(_return, returnState); + }); +} + + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::future_dropTagIndex(const ::nebula::meta::cpp2::DropTagIndexReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_dropTagIndex(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::semifuture_dropTagIndex(const ::nebula::meta::cpp2::DropTagIndexReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_dropTagIndex(rpcOptions, p_req); +} + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::future_dropTagIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropTagIndexReq& p_req) { + folly::Promise< ::nebula::meta::cpp2::ExecResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_dropTagIndex, channel_); + dropTagIndex(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::semifuture_dropTagIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropTagIndexReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_dropTagIndex, channel_); + auto callback = std::move(callbackAndFuture.first); + dropTagIndex(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> MetaServiceAsyncClient::header_future_dropTagIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropTagIndexReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_dropTagIndex, channel_); + dropTagIndex(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> MetaServiceAsyncClient::header_semifuture_dropTagIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropTagIndexReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_dropTagIndex, channel_); + auto callback = std::move(callbackAndFuture.first); + dropTagIndex(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void MetaServiceAsyncClient::dropTagIndex(folly::Function callback, const ::nebula::meta::cpp2::DropTagIndexReq& p_req) { + dropTagIndex(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper MetaServiceAsyncClient::recv_wrapped_dropTagIndex( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = MetaService_dropTagIndex_presult; + constexpr auto const fname = "dropTagIndex"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void MetaServiceAsyncClient::recv_dropTagIndex( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_dropTagIndex(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void MetaServiceAsyncClient::recv_instance_dropTagIndex( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_dropTagIndex(_return, state); +} + +folly::exception_wrapper MetaServiceAsyncClient::recv_instance_wrapped_dropTagIndex( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_dropTagIndex(_return, state); +} + +void MetaServiceAsyncClient::getTagIndex(std::unique_ptr callback, const ::nebula::meta::cpp2::GetTagIndexReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + getTagIndex(rpcOptions, std::move(callback), p_req); +} + +void MetaServiceAsyncClient::getTagIndex(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::GetTagIndexReq& p_req) { + auto ctx = getTagIndexCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + getTagIndexImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void MetaServiceAsyncClient::getTagIndexImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::GetTagIndexReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + getTagIndexT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + getTagIndexT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> MetaServiceAsyncClient::getTagIndexCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "MetaService.getTagIndex"); +} + +void MetaServiceAsyncClient::sync_getTagIndex( ::nebula::meta::cpp2::GetTagIndexResp& _return, const ::nebula::meta::cpp2::GetTagIndexReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_getTagIndex(rpcOptions, _return, p_req); +} + +void MetaServiceAsyncClient::sync_getTagIndex(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::GetTagIndexResp& _return, const ::nebula::meta::cpp2::GetTagIndexReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = getTagIndexCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + getTagIndexImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_getTagIndex(_return, returnState); + }); +} + + +folly::Future< ::nebula::meta::cpp2::GetTagIndexResp> MetaServiceAsyncClient::future_getTagIndex(const ::nebula::meta::cpp2::GetTagIndexReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_getTagIndex(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::meta::cpp2::GetTagIndexResp> MetaServiceAsyncClient::semifuture_getTagIndex(const ::nebula::meta::cpp2::GetTagIndexReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_getTagIndex(rpcOptions, p_req); +} + +folly::Future< ::nebula::meta::cpp2::GetTagIndexResp> MetaServiceAsyncClient::future_getTagIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetTagIndexReq& p_req) { + folly::Promise< ::nebula::meta::cpp2::GetTagIndexResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_getTagIndex, channel_); + getTagIndex(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::meta::cpp2::GetTagIndexResp> MetaServiceAsyncClient::semifuture_getTagIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetTagIndexReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_getTagIndex, channel_); + auto callback = std::move(callbackAndFuture.first); + getTagIndex(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> MetaServiceAsyncClient::header_future_getTagIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetTagIndexReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_getTagIndex, channel_); + getTagIndex(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> MetaServiceAsyncClient::header_semifuture_getTagIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetTagIndexReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_getTagIndex, channel_); + auto callback = std::move(callbackAndFuture.first); + getTagIndex(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void MetaServiceAsyncClient::getTagIndex(folly::Function callback, const ::nebula::meta::cpp2::GetTagIndexReq& p_req) { + getTagIndex(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper MetaServiceAsyncClient::recv_wrapped_getTagIndex( ::nebula::meta::cpp2::GetTagIndexResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = MetaService_getTagIndex_presult; + constexpr auto const fname = "getTagIndex"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void MetaServiceAsyncClient::recv_getTagIndex( ::nebula::meta::cpp2::GetTagIndexResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_getTagIndex(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void MetaServiceAsyncClient::recv_instance_getTagIndex( ::nebula::meta::cpp2::GetTagIndexResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_getTagIndex(_return, state); +} + +folly::exception_wrapper MetaServiceAsyncClient::recv_instance_wrapped_getTagIndex( ::nebula::meta::cpp2::GetTagIndexResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_getTagIndex(_return, state); +} + +void MetaServiceAsyncClient::listTagIndexes(std::unique_ptr callback, const ::nebula::meta::cpp2::ListTagIndexesReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + listTagIndexes(rpcOptions, std::move(callback), p_req); +} + +void MetaServiceAsyncClient::listTagIndexes(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::ListTagIndexesReq& p_req) { + auto ctx = listTagIndexesCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + listTagIndexesImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void MetaServiceAsyncClient::listTagIndexesImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::ListTagIndexesReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + listTagIndexesT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + listTagIndexesT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> MetaServiceAsyncClient::listTagIndexesCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "MetaService.listTagIndexes"); +} + +void MetaServiceAsyncClient::sync_listTagIndexes( ::nebula::meta::cpp2::ListTagIndexesResp& _return, const ::nebula::meta::cpp2::ListTagIndexesReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_listTagIndexes(rpcOptions, _return, p_req); +} + +void MetaServiceAsyncClient::sync_listTagIndexes(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ListTagIndexesResp& _return, const ::nebula::meta::cpp2::ListTagIndexesReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = listTagIndexesCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + listTagIndexesImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_listTagIndexes(_return, returnState); + }); +} + + +folly::Future< ::nebula::meta::cpp2::ListTagIndexesResp> MetaServiceAsyncClient::future_listTagIndexes(const ::nebula::meta::cpp2::ListTagIndexesReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_listTagIndexes(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ListTagIndexesResp> MetaServiceAsyncClient::semifuture_listTagIndexes(const ::nebula::meta::cpp2::ListTagIndexesReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_listTagIndexes(rpcOptions, p_req); +} + +folly::Future< ::nebula::meta::cpp2::ListTagIndexesResp> MetaServiceAsyncClient::future_listTagIndexes(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListTagIndexesReq& p_req) { + folly::Promise< ::nebula::meta::cpp2::ListTagIndexesResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_listTagIndexes, channel_); + listTagIndexes(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::meta::cpp2::ListTagIndexesResp> MetaServiceAsyncClient::semifuture_listTagIndexes(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListTagIndexesReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_listTagIndexes, channel_); + auto callback = std::move(callbackAndFuture.first); + listTagIndexes(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> MetaServiceAsyncClient::header_future_listTagIndexes(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListTagIndexesReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_listTagIndexes, channel_); + listTagIndexes(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> MetaServiceAsyncClient::header_semifuture_listTagIndexes(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListTagIndexesReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_listTagIndexes, channel_); + auto callback = std::move(callbackAndFuture.first); + listTagIndexes(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void MetaServiceAsyncClient::listTagIndexes(folly::Function callback, const ::nebula::meta::cpp2::ListTagIndexesReq& p_req) { + listTagIndexes(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper MetaServiceAsyncClient::recv_wrapped_listTagIndexes( ::nebula::meta::cpp2::ListTagIndexesResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = MetaService_listTagIndexes_presult; + constexpr auto const fname = "listTagIndexes"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void MetaServiceAsyncClient::recv_listTagIndexes( ::nebula::meta::cpp2::ListTagIndexesResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_listTagIndexes(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void MetaServiceAsyncClient::recv_instance_listTagIndexes( ::nebula::meta::cpp2::ListTagIndexesResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_listTagIndexes(_return, state); +} + +folly::exception_wrapper MetaServiceAsyncClient::recv_instance_wrapped_listTagIndexes( ::nebula::meta::cpp2::ListTagIndexesResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_listTagIndexes(_return, state); +} + +void MetaServiceAsyncClient::rebuildTagIndex(std::unique_ptr callback, const ::nebula::meta::cpp2::RebuildIndexReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + rebuildTagIndex(rpcOptions, std::move(callback), p_req); +} + +void MetaServiceAsyncClient::rebuildTagIndex(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::RebuildIndexReq& p_req) { + auto ctx = rebuildTagIndexCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + rebuildTagIndexImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void MetaServiceAsyncClient::rebuildTagIndexImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::RebuildIndexReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + rebuildTagIndexT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + rebuildTagIndexT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> MetaServiceAsyncClient::rebuildTagIndexCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "MetaService.rebuildTagIndex"); +} + +void MetaServiceAsyncClient::sync_rebuildTagIndex( ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::RebuildIndexReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_rebuildTagIndex(rpcOptions, _return, p_req); +} + +void MetaServiceAsyncClient::sync_rebuildTagIndex(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::RebuildIndexReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = rebuildTagIndexCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + rebuildTagIndexImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_rebuildTagIndex(_return, returnState); + }); +} + + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::future_rebuildTagIndex(const ::nebula::meta::cpp2::RebuildIndexReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_rebuildTagIndex(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::semifuture_rebuildTagIndex(const ::nebula::meta::cpp2::RebuildIndexReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_rebuildTagIndex(rpcOptions, p_req); +} + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::future_rebuildTagIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::RebuildIndexReq& p_req) { + folly::Promise< ::nebula::meta::cpp2::ExecResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_rebuildTagIndex, channel_); + rebuildTagIndex(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::semifuture_rebuildTagIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::RebuildIndexReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_rebuildTagIndex, channel_); + auto callback = std::move(callbackAndFuture.first); + rebuildTagIndex(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> MetaServiceAsyncClient::header_future_rebuildTagIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::RebuildIndexReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_rebuildTagIndex, channel_); + rebuildTagIndex(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> MetaServiceAsyncClient::header_semifuture_rebuildTagIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::RebuildIndexReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_rebuildTagIndex, channel_); + auto callback = std::move(callbackAndFuture.first); + rebuildTagIndex(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void MetaServiceAsyncClient::rebuildTagIndex(folly::Function callback, const ::nebula::meta::cpp2::RebuildIndexReq& p_req) { + rebuildTagIndex(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper MetaServiceAsyncClient::recv_wrapped_rebuildTagIndex( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = MetaService_rebuildTagIndex_presult; + constexpr auto const fname = "rebuildTagIndex"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void MetaServiceAsyncClient::recv_rebuildTagIndex( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_rebuildTagIndex(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void MetaServiceAsyncClient::recv_instance_rebuildTagIndex( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_rebuildTagIndex(_return, state); +} + +folly::exception_wrapper MetaServiceAsyncClient::recv_instance_wrapped_rebuildTagIndex( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_rebuildTagIndex(_return, state); +} + +void MetaServiceAsyncClient::listTagIndexStatus(std::unique_ptr callback, const ::nebula::meta::cpp2::ListIndexStatusReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + listTagIndexStatus(rpcOptions, std::move(callback), p_req); +} + +void MetaServiceAsyncClient::listTagIndexStatus(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::ListIndexStatusReq& p_req) { + auto ctx = listTagIndexStatusCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + listTagIndexStatusImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void MetaServiceAsyncClient::listTagIndexStatusImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::ListIndexStatusReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + listTagIndexStatusT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + listTagIndexStatusT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> MetaServiceAsyncClient::listTagIndexStatusCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "MetaService.listTagIndexStatus"); +} + +void MetaServiceAsyncClient::sync_listTagIndexStatus( ::nebula::meta::cpp2::ListIndexStatusResp& _return, const ::nebula::meta::cpp2::ListIndexStatusReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_listTagIndexStatus(rpcOptions, _return, p_req); +} + +void MetaServiceAsyncClient::sync_listTagIndexStatus(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ListIndexStatusResp& _return, const ::nebula::meta::cpp2::ListIndexStatusReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = listTagIndexStatusCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + listTagIndexStatusImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_listTagIndexStatus(_return, returnState); + }); +} + + +folly::Future< ::nebula::meta::cpp2::ListIndexStatusResp> MetaServiceAsyncClient::future_listTagIndexStatus(const ::nebula::meta::cpp2::ListIndexStatusReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_listTagIndexStatus(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ListIndexStatusResp> MetaServiceAsyncClient::semifuture_listTagIndexStatus(const ::nebula::meta::cpp2::ListIndexStatusReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_listTagIndexStatus(rpcOptions, p_req); +} + +folly::Future< ::nebula::meta::cpp2::ListIndexStatusResp> MetaServiceAsyncClient::future_listTagIndexStatus(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListIndexStatusReq& p_req) { + folly::Promise< ::nebula::meta::cpp2::ListIndexStatusResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_listTagIndexStatus, channel_); + listTagIndexStatus(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::meta::cpp2::ListIndexStatusResp> MetaServiceAsyncClient::semifuture_listTagIndexStatus(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListIndexStatusReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_listTagIndexStatus, channel_); + auto callback = std::move(callbackAndFuture.first); + listTagIndexStatus(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> MetaServiceAsyncClient::header_future_listTagIndexStatus(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListIndexStatusReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_listTagIndexStatus, channel_); + listTagIndexStatus(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> MetaServiceAsyncClient::header_semifuture_listTagIndexStatus(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListIndexStatusReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_listTagIndexStatus, channel_); + auto callback = std::move(callbackAndFuture.first); + listTagIndexStatus(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void MetaServiceAsyncClient::listTagIndexStatus(folly::Function callback, const ::nebula::meta::cpp2::ListIndexStatusReq& p_req) { + listTagIndexStatus(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper MetaServiceAsyncClient::recv_wrapped_listTagIndexStatus( ::nebula::meta::cpp2::ListIndexStatusResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = MetaService_listTagIndexStatus_presult; + constexpr auto const fname = "listTagIndexStatus"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void MetaServiceAsyncClient::recv_listTagIndexStatus( ::nebula::meta::cpp2::ListIndexStatusResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_listTagIndexStatus(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void MetaServiceAsyncClient::recv_instance_listTagIndexStatus( ::nebula::meta::cpp2::ListIndexStatusResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_listTagIndexStatus(_return, state); +} + +folly::exception_wrapper MetaServiceAsyncClient::recv_instance_wrapped_listTagIndexStatus( ::nebula::meta::cpp2::ListIndexStatusResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_listTagIndexStatus(_return, state); +} + +void MetaServiceAsyncClient::createEdgeIndex(std::unique_ptr callback, const ::nebula::meta::cpp2::CreateEdgeIndexReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + createEdgeIndex(rpcOptions, std::move(callback), p_req); +} + +void MetaServiceAsyncClient::createEdgeIndex(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::CreateEdgeIndexReq& p_req) { + auto ctx = createEdgeIndexCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + createEdgeIndexImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void MetaServiceAsyncClient::createEdgeIndexImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::CreateEdgeIndexReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + createEdgeIndexT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + createEdgeIndexT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> MetaServiceAsyncClient::createEdgeIndexCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "MetaService.createEdgeIndex"); +} + +void MetaServiceAsyncClient::sync_createEdgeIndex( ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::CreateEdgeIndexReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_createEdgeIndex(rpcOptions, _return, p_req); +} + +void MetaServiceAsyncClient::sync_createEdgeIndex(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::CreateEdgeIndexReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = createEdgeIndexCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + createEdgeIndexImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_createEdgeIndex(_return, returnState); + }); +} + + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::future_createEdgeIndex(const ::nebula::meta::cpp2::CreateEdgeIndexReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_createEdgeIndex(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::semifuture_createEdgeIndex(const ::nebula::meta::cpp2::CreateEdgeIndexReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_createEdgeIndex(rpcOptions, p_req); +} + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::future_createEdgeIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateEdgeIndexReq& p_req) { + folly::Promise< ::nebula::meta::cpp2::ExecResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_createEdgeIndex, channel_); + createEdgeIndex(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::semifuture_createEdgeIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateEdgeIndexReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_createEdgeIndex, channel_); + auto callback = std::move(callbackAndFuture.first); + createEdgeIndex(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> MetaServiceAsyncClient::header_future_createEdgeIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateEdgeIndexReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_createEdgeIndex, channel_); + createEdgeIndex(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> MetaServiceAsyncClient::header_semifuture_createEdgeIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateEdgeIndexReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_createEdgeIndex, channel_); + auto callback = std::move(callbackAndFuture.first); + createEdgeIndex(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void MetaServiceAsyncClient::createEdgeIndex(folly::Function callback, const ::nebula::meta::cpp2::CreateEdgeIndexReq& p_req) { + createEdgeIndex(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper MetaServiceAsyncClient::recv_wrapped_createEdgeIndex( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = MetaService_createEdgeIndex_presult; + constexpr auto const fname = "createEdgeIndex"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void MetaServiceAsyncClient::recv_createEdgeIndex( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_createEdgeIndex(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void MetaServiceAsyncClient::recv_instance_createEdgeIndex( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_createEdgeIndex(_return, state); +} + +folly::exception_wrapper MetaServiceAsyncClient::recv_instance_wrapped_createEdgeIndex( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_createEdgeIndex(_return, state); +} + +void MetaServiceAsyncClient::dropEdgeIndex(std::unique_ptr callback, const ::nebula::meta::cpp2::DropEdgeIndexReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + dropEdgeIndex(rpcOptions, std::move(callback), p_req); +} + +void MetaServiceAsyncClient::dropEdgeIndex(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::DropEdgeIndexReq& p_req) { + auto ctx = dropEdgeIndexCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + dropEdgeIndexImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void MetaServiceAsyncClient::dropEdgeIndexImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::DropEdgeIndexReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + dropEdgeIndexT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + dropEdgeIndexT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> MetaServiceAsyncClient::dropEdgeIndexCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "MetaService.dropEdgeIndex"); +} + +void MetaServiceAsyncClient::sync_dropEdgeIndex( ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::DropEdgeIndexReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_dropEdgeIndex(rpcOptions, _return, p_req); +} + +void MetaServiceAsyncClient::sync_dropEdgeIndex(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::DropEdgeIndexReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = dropEdgeIndexCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + dropEdgeIndexImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_dropEdgeIndex(_return, returnState); + }); +} + + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::future_dropEdgeIndex(const ::nebula::meta::cpp2::DropEdgeIndexReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_dropEdgeIndex(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::semifuture_dropEdgeIndex(const ::nebula::meta::cpp2::DropEdgeIndexReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_dropEdgeIndex(rpcOptions, p_req); +} + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::future_dropEdgeIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropEdgeIndexReq& p_req) { + folly::Promise< ::nebula::meta::cpp2::ExecResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_dropEdgeIndex, channel_); + dropEdgeIndex(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::semifuture_dropEdgeIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropEdgeIndexReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_dropEdgeIndex, channel_); + auto callback = std::move(callbackAndFuture.first); + dropEdgeIndex(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> MetaServiceAsyncClient::header_future_dropEdgeIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropEdgeIndexReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_dropEdgeIndex, channel_); + dropEdgeIndex(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> MetaServiceAsyncClient::header_semifuture_dropEdgeIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropEdgeIndexReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_dropEdgeIndex, channel_); + auto callback = std::move(callbackAndFuture.first); + dropEdgeIndex(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void MetaServiceAsyncClient::dropEdgeIndex(folly::Function callback, const ::nebula::meta::cpp2::DropEdgeIndexReq& p_req) { + dropEdgeIndex(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper MetaServiceAsyncClient::recv_wrapped_dropEdgeIndex( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = MetaService_dropEdgeIndex_presult; + constexpr auto const fname = "dropEdgeIndex"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void MetaServiceAsyncClient::recv_dropEdgeIndex( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_dropEdgeIndex(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void MetaServiceAsyncClient::recv_instance_dropEdgeIndex( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_dropEdgeIndex(_return, state); +} + +folly::exception_wrapper MetaServiceAsyncClient::recv_instance_wrapped_dropEdgeIndex( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_dropEdgeIndex(_return, state); +} + +void MetaServiceAsyncClient::getEdgeIndex(std::unique_ptr callback, const ::nebula::meta::cpp2::GetEdgeIndexReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + getEdgeIndex(rpcOptions, std::move(callback), p_req); +} + +void MetaServiceAsyncClient::getEdgeIndex(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::GetEdgeIndexReq& p_req) { + auto ctx = getEdgeIndexCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + getEdgeIndexImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void MetaServiceAsyncClient::getEdgeIndexImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::GetEdgeIndexReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + getEdgeIndexT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + getEdgeIndexT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> MetaServiceAsyncClient::getEdgeIndexCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "MetaService.getEdgeIndex"); +} + +void MetaServiceAsyncClient::sync_getEdgeIndex( ::nebula::meta::cpp2::GetEdgeIndexResp& _return, const ::nebula::meta::cpp2::GetEdgeIndexReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_getEdgeIndex(rpcOptions, _return, p_req); +} + +void MetaServiceAsyncClient::sync_getEdgeIndex(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::GetEdgeIndexResp& _return, const ::nebula::meta::cpp2::GetEdgeIndexReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = getEdgeIndexCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + getEdgeIndexImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_getEdgeIndex(_return, returnState); + }); +} + + +folly::Future< ::nebula::meta::cpp2::GetEdgeIndexResp> MetaServiceAsyncClient::future_getEdgeIndex(const ::nebula::meta::cpp2::GetEdgeIndexReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_getEdgeIndex(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::meta::cpp2::GetEdgeIndexResp> MetaServiceAsyncClient::semifuture_getEdgeIndex(const ::nebula::meta::cpp2::GetEdgeIndexReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_getEdgeIndex(rpcOptions, p_req); +} + +folly::Future< ::nebula::meta::cpp2::GetEdgeIndexResp> MetaServiceAsyncClient::future_getEdgeIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetEdgeIndexReq& p_req) { + folly::Promise< ::nebula::meta::cpp2::GetEdgeIndexResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_getEdgeIndex, channel_); + getEdgeIndex(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::meta::cpp2::GetEdgeIndexResp> MetaServiceAsyncClient::semifuture_getEdgeIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetEdgeIndexReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_getEdgeIndex, channel_); + auto callback = std::move(callbackAndFuture.first); + getEdgeIndex(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> MetaServiceAsyncClient::header_future_getEdgeIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetEdgeIndexReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_getEdgeIndex, channel_); + getEdgeIndex(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> MetaServiceAsyncClient::header_semifuture_getEdgeIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetEdgeIndexReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_getEdgeIndex, channel_); + auto callback = std::move(callbackAndFuture.first); + getEdgeIndex(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void MetaServiceAsyncClient::getEdgeIndex(folly::Function callback, const ::nebula::meta::cpp2::GetEdgeIndexReq& p_req) { + getEdgeIndex(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper MetaServiceAsyncClient::recv_wrapped_getEdgeIndex( ::nebula::meta::cpp2::GetEdgeIndexResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = MetaService_getEdgeIndex_presult; + constexpr auto const fname = "getEdgeIndex"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void MetaServiceAsyncClient::recv_getEdgeIndex( ::nebula::meta::cpp2::GetEdgeIndexResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_getEdgeIndex(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void MetaServiceAsyncClient::recv_instance_getEdgeIndex( ::nebula::meta::cpp2::GetEdgeIndexResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_getEdgeIndex(_return, state); +} + +folly::exception_wrapper MetaServiceAsyncClient::recv_instance_wrapped_getEdgeIndex( ::nebula::meta::cpp2::GetEdgeIndexResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_getEdgeIndex(_return, state); +} + +void MetaServiceAsyncClient::listEdgeIndexes(std::unique_ptr callback, const ::nebula::meta::cpp2::ListEdgeIndexesReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + listEdgeIndexes(rpcOptions, std::move(callback), p_req); +} + +void MetaServiceAsyncClient::listEdgeIndexes(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::ListEdgeIndexesReq& p_req) { + auto ctx = listEdgeIndexesCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + listEdgeIndexesImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void MetaServiceAsyncClient::listEdgeIndexesImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::ListEdgeIndexesReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + listEdgeIndexesT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + listEdgeIndexesT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> MetaServiceAsyncClient::listEdgeIndexesCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "MetaService.listEdgeIndexes"); +} + +void MetaServiceAsyncClient::sync_listEdgeIndexes( ::nebula::meta::cpp2::ListEdgeIndexesResp& _return, const ::nebula::meta::cpp2::ListEdgeIndexesReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_listEdgeIndexes(rpcOptions, _return, p_req); +} + +void MetaServiceAsyncClient::sync_listEdgeIndexes(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ListEdgeIndexesResp& _return, const ::nebula::meta::cpp2::ListEdgeIndexesReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = listEdgeIndexesCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + listEdgeIndexesImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_listEdgeIndexes(_return, returnState); + }); +} + + +folly::Future< ::nebula::meta::cpp2::ListEdgeIndexesResp> MetaServiceAsyncClient::future_listEdgeIndexes(const ::nebula::meta::cpp2::ListEdgeIndexesReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_listEdgeIndexes(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ListEdgeIndexesResp> MetaServiceAsyncClient::semifuture_listEdgeIndexes(const ::nebula::meta::cpp2::ListEdgeIndexesReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_listEdgeIndexes(rpcOptions, p_req); +} + +folly::Future< ::nebula::meta::cpp2::ListEdgeIndexesResp> MetaServiceAsyncClient::future_listEdgeIndexes(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListEdgeIndexesReq& p_req) { + folly::Promise< ::nebula::meta::cpp2::ListEdgeIndexesResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_listEdgeIndexes, channel_); + listEdgeIndexes(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::meta::cpp2::ListEdgeIndexesResp> MetaServiceAsyncClient::semifuture_listEdgeIndexes(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListEdgeIndexesReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_listEdgeIndexes, channel_); + auto callback = std::move(callbackAndFuture.first); + listEdgeIndexes(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> MetaServiceAsyncClient::header_future_listEdgeIndexes(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListEdgeIndexesReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_listEdgeIndexes, channel_); + listEdgeIndexes(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> MetaServiceAsyncClient::header_semifuture_listEdgeIndexes(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListEdgeIndexesReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_listEdgeIndexes, channel_); + auto callback = std::move(callbackAndFuture.first); + listEdgeIndexes(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void MetaServiceAsyncClient::listEdgeIndexes(folly::Function callback, const ::nebula::meta::cpp2::ListEdgeIndexesReq& p_req) { + listEdgeIndexes(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper MetaServiceAsyncClient::recv_wrapped_listEdgeIndexes( ::nebula::meta::cpp2::ListEdgeIndexesResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = MetaService_listEdgeIndexes_presult; + constexpr auto const fname = "listEdgeIndexes"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void MetaServiceAsyncClient::recv_listEdgeIndexes( ::nebula::meta::cpp2::ListEdgeIndexesResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_listEdgeIndexes(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void MetaServiceAsyncClient::recv_instance_listEdgeIndexes( ::nebula::meta::cpp2::ListEdgeIndexesResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_listEdgeIndexes(_return, state); +} + +folly::exception_wrapper MetaServiceAsyncClient::recv_instance_wrapped_listEdgeIndexes( ::nebula::meta::cpp2::ListEdgeIndexesResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_listEdgeIndexes(_return, state); +} + +void MetaServiceAsyncClient::rebuildEdgeIndex(std::unique_ptr callback, const ::nebula::meta::cpp2::RebuildIndexReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + rebuildEdgeIndex(rpcOptions, std::move(callback), p_req); +} + +void MetaServiceAsyncClient::rebuildEdgeIndex(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::RebuildIndexReq& p_req) { + auto ctx = rebuildEdgeIndexCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + rebuildEdgeIndexImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void MetaServiceAsyncClient::rebuildEdgeIndexImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::RebuildIndexReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + rebuildEdgeIndexT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + rebuildEdgeIndexT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> MetaServiceAsyncClient::rebuildEdgeIndexCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "MetaService.rebuildEdgeIndex"); +} + +void MetaServiceAsyncClient::sync_rebuildEdgeIndex( ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::RebuildIndexReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_rebuildEdgeIndex(rpcOptions, _return, p_req); +} + +void MetaServiceAsyncClient::sync_rebuildEdgeIndex(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::RebuildIndexReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = rebuildEdgeIndexCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + rebuildEdgeIndexImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_rebuildEdgeIndex(_return, returnState); + }); +} + + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::future_rebuildEdgeIndex(const ::nebula::meta::cpp2::RebuildIndexReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_rebuildEdgeIndex(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::semifuture_rebuildEdgeIndex(const ::nebula::meta::cpp2::RebuildIndexReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_rebuildEdgeIndex(rpcOptions, p_req); +} + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::future_rebuildEdgeIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::RebuildIndexReq& p_req) { + folly::Promise< ::nebula::meta::cpp2::ExecResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_rebuildEdgeIndex, channel_); + rebuildEdgeIndex(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::semifuture_rebuildEdgeIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::RebuildIndexReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_rebuildEdgeIndex, channel_); + auto callback = std::move(callbackAndFuture.first); + rebuildEdgeIndex(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> MetaServiceAsyncClient::header_future_rebuildEdgeIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::RebuildIndexReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_rebuildEdgeIndex, channel_); + rebuildEdgeIndex(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> MetaServiceAsyncClient::header_semifuture_rebuildEdgeIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::RebuildIndexReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_rebuildEdgeIndex, channel_); + auto callback = std::move(callbackAndFuture.first); + rebuildEdgeIndex(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void MetaServiceAsyncClient::rebuildEdgeIndex(folly::Function callback, const ::nebula::meta::cpp2::RebuildIndexReq& p_req) { + rebuildEdgeIndex(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper MetaServiceAsyncClient::recv_wrapped_rebuildEdgeIndex( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = MetaService_rebuildEdgeIndex_presult; + constexpr auto const fname = "rebuildEdgeIndex"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void MetaServiceAsyncClient::recv_rebuildEdgeIndex( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_rebuildEdgeIndex(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void MetaServiceAsyncClient::recv_instance_rebuildEdgeIndex( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_rebuildEdgeIndex(_return, state); +} + +folly::exception_wrapper MetaServiceAsyncClient::recv_instance_wrapped_rebuildEdgeIndex( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_rebuildEdgeIndex(_return, state); +} + +void MetaServiceAsyncClient::listEdgeIndexStatus(std::unique_ptr callback, const ::nebula::meta::cpp2::ListIndexStatusReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + listEdgeIndexStatus(rpcOptions, std::move(callback), p_req); +} + +void MetaServiceAsyncClient::listEdgeIndexStatus(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::ListIndexStatusReq& p_req) { + auto ctx = listEdgeIndexStatusCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + listEdgeIndexStatusImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void MetaServiceAsyncClient::listEdgeIndexStatusImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::ListIndexStatusReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + listEdgeIndexStatusT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + listEdgeIndexStatusT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> MetaServiceAsyncClient::listEdgeIndexStatusCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "MetaService.listEdgeIndexStatus"); +} + +void MetaServiceAsyncClient::sync_listEdgeIndexStatus( ::nebula::meta::cpp2::ListIndexStatusResp& _return, const ::nebula::meta::cpp2::ListIndexStatusReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_listEdgeIndexStatus(rpcOptions, _return, p_req); +} + +void MetaServiceAsyncClient::sync_listEdgeIndexStatus(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ListIndexStatusResp& _return, const ::nebula::meta::cpp2::ListIndexStatusReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = listEdgeIndexStatusCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + listEdgeIndexStatusImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_listEdgeIndexStatus(_return, returnState); + }); +} + + +folly::Future< ::nebula::meta::cpp2::ListIndexStatusResp> MetaServiceAsyncClient::future_listEdgeIndexStatus(const ::nebula::meta::cpp2::ListIndexStatusReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_listEdgeIndexStatus(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ListIndexStatusResp> MetaServiceAsyncClient::semifuture_listEdgeIndexStatus(const ::nebula::meta::cpp2::ListIndexStatusReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_listEdgeIndexStatus(rpcOptions, p_req); +} + +folly::Future< ::nebula::meta::cpp2::ListIndexStatusResp> MetaServiceAsyncClient::future_listEdgeIndexStatus(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListIndexStatusReq& p_req) { + folly::Promise< ::nebula::meta::cpp2::ListIndexStatusResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_listEdgeIndexStatus, channel_); + listEdgeIndexStatus(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::meta::cpp2::ListIndexStatusResp> MetaServiceAsyncClient::semifuture_listEdgeIndexStatus(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListIndexStatusReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_listEdgeIndexStatus, channel_); + auto callback = std::move(callbackAndFuture.first); + listEdgeIndexStatus(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> MetaServiceAsyncClient::header_future_listEdgeIndexStatus(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListIndexStatusReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_listEdgeIndexStatus, channel_); + listEdgeIndexStatus(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> MetaServiceAsyncClient::header_semifuture_listEdgeIndexStatus(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListIndexStatusReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_listEdgeIndexStatus, channel_); + auto callback = std::move(callbackAndFuture.first); + listEdgeIndexStatus(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void MetaServiceAsyncClient::listEdgeIndexStatus(folly::Function callback, const ::nebula::meta::cpp2::ListIndexStatusReq& p_req) { + listEdgeIndexStatus(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper MetaServiceAsyncClient::recv_wrapped_listEdgeIndexStatus( ::nebula::meta::cpp2::ListIndexStatusResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = MetaService_listEdgeIndexStatus_presult; + constexpr auto const fname = "listEdgeIndexStatus"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void MetaServiceAsyncClient::recv_listEdgeIndexStatus( ::nebula::meta::cpp2::ListIndexStatusResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_listEdgeIndexStatus(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void MetaServiceAsyncClient::recv_instance_listEdgeIndexStatus( ::nebula::meta::cpp2::ListIndexStatusResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_listEdgeIndexStatus(_return, state); +} + +folly::exception_wrapper MetaServiceAsyncClient::recv_instance_wrapped_listEdgeIndexStatus( ::nebula::meta::cpp2::ListIndexStatusResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_listEdgeIndexStatus(_return, state); +} + +void MetaServiceAsyncClient::createUser(std::unique_ptr callback, const ::nebula::meta::cpp2::CreateUserReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + createUser(rpcOptions, std::move(callback), p_req); +} + +void MetaServiceAsyncClient::createUser(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::CreateUserReq& p_req) { + auto ctx = createUserCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + createUserImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void MetaServiceAsyncClient::createUserImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::CreateUserReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + createUserT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + createUserT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> MetaServiceAsyncClient::createUserCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "MetaService.createUser"); +} + +void MetaServiceAsyncClient::sync_createUser( ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::CreateUserReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_createUser(rpcOptions, _return, p_req); +} + +void MetaServiceAsyncClient::sync_createUser(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::CreateUserReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = createUserCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + createUserImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_createUser(_return, returnState); + }); +} + + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::future_createUser(const ::nebula::meta::cpp2::CreateUserReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_createUser(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::semifuture_createUser(const ::nebula::meta::cpp2::CreateUserReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_createUser(rpcOptions, p_req); +} + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::future_createUser(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateUserReq& p_req) { + folly::Promise< ::nebula::meta::cpp2::ExecResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_createUser, channel_); + createUser(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::semifuture_createUser(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateUserReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_createUser, channel_); + auto callback = std::move(callbackAndFuture.first); + createUser(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> MetaServiceAsyncClient::header_future_createUser(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateUserReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_createUser, channel_); + createUser(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> MetaServiceAsyncClient::header_semifuture_createUser(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateUserReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_createUser, channel_); + auto callback = std::move(callbackAndFuture.first); + createUser(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void MetaServiceAsyncClient::createUser(folly::Function callback, const ::nebula::meta::cpp2::CreateUserReq& p_req) { + createUser(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper MetaServiceAsyncClient::recv_wrapped_createUser( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = MetaService_createUser_presult; + constexpr auto const fname = "createUser"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void MetaServiceAsyncClient::recv_createUser( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_createUser(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void MetaServiceAsyncClient::recv_instance_createUser( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_createUser(_return, state); +} + +folly::exception_wrapper MetaServiceAsyncClient::recv_instance_wrapped_createUser( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_createUser(_return, state); +} + +void MetaServiceAsyncClient::dropUser(std::unique_ptr callback, const ::nebula::meta::cpp2::DropUserReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + dropUser(rpcOptions, std::move(callback), p_req); +} + +void MetaServiceAsyncClient::dropUser(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::DropUserReq& p_req) { + auto ctx = dropUserCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + dropUserImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void MetaServiceAsyncClient::dropUserImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::DropUserReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + dropUserT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + dropUserT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> MetaServiceAsyncClient::dropUserCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "MetaService.dropUser"); +} + +void MetaServiceAsyncClient::sync_dropUser( ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::DropUserReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_dropUser(rpcOptions, _return, p_req); +} + +void MetaServiceAsyncClient::sync_dropUser(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::DropUserReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = dropUserCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + dropUserImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_dropUser(_return, returnState); + }); +} + + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::future_dropUser(const ::nebula::meta::cpp2::DropUserReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_dropUser(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::semifuture_dropUser(const ::nebula::meta::cpp2::DropUserReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_dropUser(rpcOptions, p_req); +} + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::future_dropUser(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropUserReq& p_req) { + folly::Promise< ::nebula::meta::cpp2::ExecResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_dropUser, channel_); + dropUser(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::semifuture_dropUser(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropUserReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_dropUser, channel_); + auto callback = std::move(callbackAndFuture.first); + dropUser(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> MetaServiceAsyncClient::header_future_dropUser(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropUserReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_dropUser, channel_); + dropUser(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> MetaServiceAsyncClient::header_semifuture_dropUser(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropUserReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_dropUser, channel_); + auto callback = std::move(callbackAndFuture.first); + dropUser(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void MetaServiceAsyncClient::dropUser(folly::Function callback, const ::nebula::meta::cpp2::DropUserReq& p_req) { + dropUser(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper MetaServiceAsyncClient::recv_wrapped_dropUser( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = MetaService_dropUser_presult; + constexpr auto const fname = "dropUser"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void MetaServiceAsyncClient::recv_dropUser( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_dropUser(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void MetaServiceAsyncClient::recv_instance_dropUser( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_dropUser(_return, state); +} + +folly::exception_wrapper MetaServiceAsyncClient::recv_instance_wrapped_dropUser( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_dropUser(_return, state); +} + +void MetaServiceAsyncClient::alterUser(std::unique_ptr callback, const ::nebula::meta::cpp2::AlterUserReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + alterUser(rpcOptions, std::move(callback), p_req); +} + +void MetaServiceAsyncClient::alterUser(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::AlterUserReq& p_req) { + auto ctx = alterUserCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + alterUserImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void MetaServiceAsyncClient::alterUserImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::AlterUserReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + alterUserT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + alterUserT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> MetaServiceAsyncClient::alterUserCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "MetaService.alterUser"); +} + +void MetaServiceAsyncClient::sync_alterUser( ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::AlterUserReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_alterUser(rpcOptions, _return, p_req); +} + +void MetaServiceAsyncClient::sync_alterUser(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::AlterUserReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = alterUserCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + alterUserImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_alterUser(_return, returnState); + }); +} + + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::future_alterUser(const ::nebula::meta::cpp2::AlterUserReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_alterUser(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::semifuture_alterUser(const ::nebula::meta::cpp2::AlterUserReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_alterUser(rpcOptions, p_req); +} + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::future_alterUser(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::AlterUserReq& p_req) { + folly::Promise< ::nebula::meta::cpp2::ExecResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_alterUser, channel_); + alterUser(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::semifuture_alterUser(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::AlterUserReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_alterUser, channel_); + auto callback = std::move(callbackAndFuture.first); + alterUser(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> MetaServiceAsyncClient::header_future_alterUser(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::AlterUserReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_alterUser, channel_); + alterUser(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> MetaServiceAsyncClient::header_semifuture_alterUser(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::AlterUserReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_alterUser, channel_); + auto callback = std::move(callbackAndFuture.first); + alterUser(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void MetaServiceAsyncClient::alterUser(folly::Function callback, const ::nebula::meta::cpp2::AlterUserReq& p_req) { + alterUser(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper MetaServiceAsyncClient::recv_wrapped_alterUser( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = MetaService_alterUser_presult; + constexpr auto const fname = "alterUser"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void MetaServiceAsyncClient::recv_alterUser( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_alterUser(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void MetaServiceAsyncClient::recv_instance_alterUser( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_alterUser(_return, state); +} + +folly::exception_wrapper MetaServiceAsyncClient::recv_instance_wrapped_alterUser( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_alterUser(_return, state); +} + +void MetaServiceAsyncClient::grantRole(std::unique_ptr callback, const ::nebula::meta::cpp2::GrantRoleReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + grantRole(rpcOptions, std::move(callback), p_req); +} + +void MetaServiceAsyncClient::grantRole(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::GrantRoleReq& p_req) { + auto ctx = grantRoleCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + grantRoleImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void MetaServiceAsyncClient::grantRoleImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::GrantRoleReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + grantRoleT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + grantRoleT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> MetaServiceAsyncClient::grantRoleCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "MetaService.grantRole"); +} + +void MetaServiceAsyncClient::sync_grantRole( ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::GrantRoleReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_grantRole(rpcOptions, _return, p_req); +} + +void MetaServiceAsyncClient::sync_grantRole(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::GrantRoleReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = grantRoleCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + grantRoleImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_grantRole(_return, returnState); + }); +} + + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::future_grantRole(const ::nebula::meta::cpp2::GrantRoleReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_grantRole(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::semifuture_grantRole(const ::nebula::meta::cpp2::GrantRoleReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_grantRole(rpcOptions, p_req); +} + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::future_grantRole(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GrantRoleReq& p_req) { + folly::Promise< ::nebula::meta::cpp2::ExecResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_grantRole, channel_); + grantRole(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::semifuture_grantRole(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GrantRoleReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_grantRole, channel_); + auto callback = std::move(callbackAndFuture.first); + grantRole(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> MetaServiceAsyncClient::header_future_grantRole(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GrantRoleReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_grantRole, channel_); + grantRole(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> MetaServiceAsyncClient::header_semifuture_grantRole(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GrantRoleReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_grantRole, channel_); + auto callback = std::move(callbackAndFuture.first); + grantRole(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void MetaServiceAsyncClient::grantRole(folly::Function callback, const ::nebula::meta::cpp2::GrantRoleReq& p_req) { + grantRole(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper MetaServiceAsyncClient::recv_wrapped_grantRole( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = MetaService_grantRole_presult; + constexpr auto const fname = "grantRole"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void MetaServiceAsyncClient::recv_grantRole( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_grantRole(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void MetaServiceAsyncClient::recv_instance_grantRole( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_grantRole(_return, state); +} + +folly::exception_wrapper MetaServiceAsyncClient::recv_instance_wrapped_grantRole( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_grantRole(_return, state); +} + +void MetaServiceAsyncClient::revokeRole(std::unique_ptr callback, const ::nebula::meta::cpp2::RevokeRoleReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + revokeRole(rpcOptions, std::move(callback), p_req); +} + +void MetaServiceAsyncClient::revokeRole(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::RevokeRoleReq& p_req) { + auto ctx = revokeRoleCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + revokeRoleImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void MetaServiceAsyncClient::revokeRoleImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::RevokeRoleReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + revokeRoleT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + revokeRoleT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> MetaServiceAsyncClient::revokeRoleCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "MetaService.revokeRole"); +} + +void MetaServiceAsyncClient::sync_revokeRole( ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::RevokeRoleReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_revokeRole(rpcOptions, _return, p_req); +} + +void MetaServiceAsyncClient::sync_revokeRole(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::RevokeRoleReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = revokeRoleCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + revokeRoleImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_revokeRole(_return, returnState); + }); +} + + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::future_revokeRole(const ::nebula::meta::cpp2::RevokeRoleReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_revokeRole(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::semifuture_revokeRole(const ::nebula::meta::cpp2::RevokeRoleReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_revokeRole(rpcOptions, p_req); +} + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::future_revokeRole(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::RevokeRoleReq& p_req) { + folly::Promise< ::nebula::meta::cpp2::ExecResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_revokeRole, channel_); + revokeRole(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::semifuture_revokeRole(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::RevokeRoleReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_revokeRole, channel_); + auto callback = std::move(callbackAndFuture.first); + revokeRole(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> MetaServiceAsyncClient::header_future_revokeRole(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::RevokeRoleReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_revokeRole, channel_); + revokeRole(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> MetaServiceAsyncClient::header_semifuture_revokeRole(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::RevokeRoleReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_revokeRole, channel_); + auto callback = std::move(callbackAndFuture.first); + revokeRole(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void MetaServiceAsyncClient::revokeRole(folly::Function callback, const ::nebula::meta::cpp2::RevokeRoleReq& p_req) { + revokeRole(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper MetaServiceAsyncClient::recv_wrapped_revokeRole( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = MetaService_revokeRole_presult; + constexpr auto const fname = "revokeRole"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void MetaServiceAsyncClient::recv_revokeRole( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_revokeRole(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void MetaServiceAsyncClient::recv_instance_revokeRole( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_revokeRole(_return, state); +} + +folly::exception_wrapper MetaServiceAsyncClient::recv_instance_wrapped_revokeRole( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_revokeRole(_return, state); +} + +void MetaServiceAsyncClient::listUsers(std::unique_ptr callback, const ::nebula::meta::cpp2::ListUsersReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + listUsers(rpcOptions, std::move(callback), p_req); +} + +void MetaServiceAsyncClient::listUsers(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::ListUsersReq& p_req) { + auto ctx = listUsersCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + listUsersImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void MetaServiceAsyncClient::listUsersImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::ListUsersReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + listUsersT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + listUsersT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> MetaServiceAsyncClient::listUsersCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "MetaService.listUsers"); +} + +void MetaServiceAsyncClient::sync_listUsers( ::nebula::meta::cpp2::ListUsersResp& _return, const ::nebula::meta::cpp2::ListUsersReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_listUsers(rpcOptions, _return, p_req); +} + +void MetaServiceAsyncClient::sync_listUsers(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ListUsersResp& _return, const ::nebula::meta::cpp2::ListUsersReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = listUsersCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + listUsersImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_listUsers(_return, returnState); + }); +} + + +folly::Future< ::nebula::meta::cpp2::ListUsersResp> MetaServiceAsyncClient::future_listUsers(const ::nebula::meta::cpp2::ListUsersReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_listUsers(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ListUsersResp> MetaServiceAsyncClient::semifuture_listUsers(const ::nebula::meta::cpp2::ListUsersReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_listUsers(rpcOptions, p_req); +} + +folly::Future< ::nebula::meta::cpp2::ListUsersResp> MetaServiceAsyncClient::future_listUsers(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListUsersReq& p_req) { + folly::Promise< ::nebula::meta::cpp2::ListUsersResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_listUsers, channel_); + listUsers(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::meta::cpp2::ListUsersResp> MetaServiceAsyncClient::semifuture_listUsers(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListUsersReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_listUsers, channel_); + auto callback = std::move(callbackAndFuture.first); + listUsers(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> MetaServiceAsyncClient::header_future_listUsers(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListUsersReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_listUsers, channel_); + listUsers(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> MetaServiceAsyncClient::header_semifuture_listUsers(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListUsersReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_listUsers, channel_); + auto callback = std::move(callbackAndFuture.first); + listUsers(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void MetaServiceAsyncClient::listUsers(folly::Function callback, const ::nebula::meta::cpp2::ListUsersReq& p_req) { + listUsers(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper MetaServiceAsyncClient::recv_wrapped_listUsers( ::nebula::meta::cpp2::ListUsersResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = MetaService_listUsers_presult; + constexpr auto const fname = "listUsers"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void MetaServiceAsyncClient::recv_listUsers( ::nebula::meta::cpp2::ListUsersResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_listUsers(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void MetaServiceAsyncClient::recv_instance_listUsers( ::nebula::meta::cpp2::ListUsersResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_listUsers(_return, state); +} + +folly::exception_wrapper MetaServiceAsyncClient::recv_instance_wrapped_listUsers( ::nebula::meta::cpp2::ListUsersResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_listUsers(_return, state); +} + +void MetaServiceAsyncClient::listRoles(std::unique_ptr callback, const ::nebula::meta::cpp2::ListRolesReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + listRoles(rpcOptions, std::move(callback), p_req); +} + +void MetaServiceAsyncClient::listRoles(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::ListRolesReq& p_req) { + auto ctx = listRolesCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + listRolesImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void MetaServiceAsyncClient::listRolesImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::ListRolesReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + listRolesT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + listRolesT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> MetaServiceAsyncClient::listRolesCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "MetaService.listRoles"); +} + +void MetaServiceAsyncClient::sync_listRoles( ::nebula::meta::cpp2::ListRolesResp& _return, const ::nebula::meta::cpp2::ListRolesReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_listRoles(rpcOptions, _return, p_req); +} + +void MetaServiceAsyncClient::sync_listRoles(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ListRolesResp& _return, const ::nebula::meta::cpp2::ListRolesReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = listRolesCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + listRolesImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_listRoles(_return, returnState); + }); +} + + +folly::Future< ::nebula::meta::cpp2::ListRolesResp> MetaServiceAsyncClient::future_listRoles(const ::nebula::meta::cpp2::ListRolesReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_listRoles(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ListRolesResp> MetaServiceAsyncClient::semifuture_listRoles(const ::nebula::meta::cpp2::ListRolesReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_listRoles(rpcOptions, p_req); +} + +folly::Future< ::nebula::meta::cpp2::ListRolesResp> MetaServiceAsyncClient::future_listRoles(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListRolesReq& p_req) { + folly::Promise< ::nebula::meta::cpp2::ListRolesResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_listRoles, channel_); + listRoles(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::meta::cpp2::ListRolesResp> MetaServiceAsyncClient::semifuture_listRoles(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListRolesReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_listRoles, channel_); + auto callback = std::move(callbackAndFuture.first); + listRoles(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> MetaServiceAsyncClient::header_future_listRoles(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListRolesReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_listRoles, channel_); + listRoles(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> MetaServiceAsyncClient::header_semifuture_listRoles(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListRolesReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_listRoles, channel_); + auto callback = std::move(callbackAndFuture.first); + listRoles(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void MetaServiceAsyncClient::listRoles(folly::Function callback, const ::nebula::meta::cpp2::ListRolesReq& p_req) { + listRoles(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper MetaServiceAsyncClient::recv_wrapped_listRoles( ::nebula::meta::cpp2::ListRolesResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = MetaService_listRoles_presult; + constexpr auto const fname = "listRoles"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void MetaServiceAsyncClient::recv_listRoles( ::nebula::meta::cpp2::ListRolesResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_listRoles(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void MetaServiceAsyncClient::recv_instance_listRoles( ::nebula::meta::cpp2::ListRolesResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_listRoles(_return, state); +} + +folly::exception_wrapper MetaServiceAsyncClient::recv_instance_wrapped_listRoles( ::nebula::meta::cpp2::ListRolesResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_listRoles(_return, state); +} + +void MetaServiceAsyncClient::getUserRoles(std::unique_ptr callback, const ::nebula::meta::cpp2::GetUserRolesReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + getUserRoles(rpcOptions, std::move(callback), p_req); +} + +void MetaServiceAsyncClient::getUserRoles(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::GetUserRolesReq& p_req) { + auto ctx = getUserRolesCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + getUserRolesImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void MetaServiceAsyncClient::getUserRolesImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::GetUserRolesReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + getUserRolesT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + getUserRolesT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> MetaServiceAsyncClient::getUserRolesCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "MetaService.getUserRoles"); +} + +void MetaServiceAsyncClient::sync_getUserRoles( ::nebula::meta::cpp2::ListRolesResp& _return, const ::nebula::meta::cpp2::GetUserRolesReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_getUserRoles(rpcOptions, _return, p_req); +} + +void MetaServiceAsyncClient::sync_getUserRoles(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ListRolesResp& _return, const ::nebula::meta::cpp2::GetUserRolesReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = getUserRolesCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + getUserRolesImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_getUserRoles(_return, returnState); + }); +} + + +folly::Future< ::nebula::meta::cpp2::ListRolesResp> MetaServiceAsyncClient::future_getUserRoles(const ::nebula::meta::cpp2::GetUserRolesReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_getUserRoles(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ListRolesResp> MetaServiceAsyncClient::semifuture_getUserRoles(const ::nebula::meta::cpp2::GetUserRolesReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_getUserRoles(rpcOptions, p_req); +} + +folly::Future< ::nebula::meta::cpp2::ListRolesResp> MetaServiceAsyncClient::future_getUserRoles(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetUserRolesReq& p_req) { + folly::Promise< ::nebula::meta::cpp2::ListRolesResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_getUserRoles, channel_); + getUserRoles(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::meta::cpp2::ListRolesResp> MetaServiceAsyncClient::semifuture_getUserRoles(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetUserRolesReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_getUserRoles, channel_); + auto callback = std::move(callbackAndFuture.first); + getUserRoles(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> MetaServiceAsyncClient::header_future_getUserRoles(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetUserRolesReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_getUserRoles, channel_); + getUserRoles(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> MetaServiceAsyncClient::header_semifuture_getUserRoles(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetUserRolesReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_getUserRoles, channel_); + auto callback = std::move(callbackAndFuture.first); + getUserRoles(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void MetaServiceAsyncClient::getUserRoles(folly::Function callback, const ::nebula::meta::cpp2::GetUserRolesReq& p_req) { + getUserRoles(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper MetaServiceAsyncClient::recv_wrapped_getUserRoles( ::nebula::meta::cpp2::ListRolesResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = MetaService_getUserRoles_presult; + constexpr auto const fname = "getUserRoles"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void MetaServiceAsyncClient::recv_getUserRoles( ::nebula::meta::cpp2::ListRolesResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_getUserRoles(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void MetaServiceAsyncClient::recv_instance_getUserRoles( ::nebula::meta::cpp2::ListRolesResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_getUserRoles(_return, state); +} + +folly::exception_wrapper MetaServiceAsyncClient::recv_instance_wrapped_getUserRoles( ::nebula::meta::cpp2::ListRolesResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_getUserRoles(_return, state); +} + +void MetaServiceAsyncClient::changePassword(std::unique_ptr callback, const ::nebula::meta::cpp2::ChangePasswordReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + changePassword(rpcOptions, std::move(callback), p_req); +} + +void MetaServiceAsyncClient::changePassword(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::ChangePasswordReq& p_req) { + auto ctx = changePasswordCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + changePasswordImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void MetaServiceAsyncClient::changePasswordImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::ChangePasswordReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + changePasswordT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + changePasswordT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> MetaServiceAsyncClient::changePasswordCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "MetaService.changePassword"); +} + +void MetaServiceAsyncClient::sync_changePassword( ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::ChangePasswordReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_changePassword(rpcOptions, _return, p_req); +} + +void MetaServiceAsyncClient::sync_changePassword(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::ChangePasswordReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = changePasswordCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + changePasswordImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_changePassword(_return, returnState); + }); +} + + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::future_changePassword(const ::nebula::meta::cpp2::ChangePasswordReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_changePassword(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::semifuture_changePassword(const ::nebula::meta::cpp2::ChangePasswordReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_changePassword(rpcOptions, p_req); +} + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::future_changePassword(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ChangePasswordReq& p_req) { + folly::Promise< ::nebula::meta::cpp2::ExecResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_changePassword, channel_); + changePassword(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::semifuture_changePassword(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ChangePasswordReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_changePassword, channel_); + auto callback = std::move(callbackAndFuture.first); + changePassword(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> MetaServiceAsyncClient::header_future_changePassword(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ChangePasswordReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_changePassword, channel_); + changePassword(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> MetaServiceAsyncClient::header_semifuture_changePassword(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ChangePasswordReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_changePassword, channel_); + auto callback = std::move(callbackAndFuture.first); + changePassword(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void MetaServiceAsyncClient::changePassword(folly::Function callback, const ::nebula::meta::cpp2::ChangePasswordReq& p_req) { + changePassword(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper MetaServiceAsyncClient::recv_wrapped_changePassword( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = MetaService_changePassword_presult; + constexpr auto const fname = "changePassword"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void MetaServiceAsyncClient::recv_changePassword( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_changePassword(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void MetaServiceAsyncClient::recv_instance_changePassword( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_changePassword(_return, state); +} + +folly::exception_wrapper MetaServiceAsyncClient::recv_instance_wrapped_changePassword( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_changePassword(_return, state); +} + +void MetaServiceAsyncClient::heartBeat(std::unique_ptr callback, const ::nebula::meta::cpp2::HBReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + heartBeat(rpcOptions, std::move(callback), p_req); +} + +void MetaServiceAsyncClient::heartBeat(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::HBReq& p_req) { + auto ctx = heartBeatCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + heartBeatImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void MetaServiceAsyncClient::heartBeatImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::HBReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + heartBeatT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + heartBeatT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> MetaServiceAsyncClient::heartBeatCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "MetaService.heartBeat"); +} + +void MetaServiceAsyncClient::sync_heartBeat( ::nebula::meta::cpp2::HBResp& _return, const ::nebula::meta::cpp2::HBReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_heartBeat(rpcOptions, _return, p_req); +} + +void MetaServiceAsyncClient::sync_heartBeat(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::HBResp& _return, const ::nebula::meta::cpp2::HBReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = heartBeatCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + heartBeatImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_heartBeat(_return, returnState); + }); +} + + +folly::Future< ::nebula::meta::cpp2::HBResp> MetaServiceAsyncClient::future_heartBeat(const ::nebula::meta::cpp2::HBReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_heartBeat(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::meta::cpp2::HBResp> MetaServiceAsyncClient::semifuture_heartBeat(const ::nebula::meta::cpp2::HBReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_heartBeat(rpcOptions, p_req); +} + +folly::Future< ::nebula::meta::cpp2::HBResp> MetaServiceAsyncClient::future_heartBeat(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::HBReq& p_req) { + folly::Promise< ::nebula::meta::cpp2::HBResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_heartBeat, channel_); + heartBeat(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::meta::cpp2::HBResp> MetaServiceAsyncClient::semifuture_heartBeat(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::HBReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_heartBeat, channel_); + auto callback = std::move(callbackAndFuture.first); + heartBeat(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> MetaServiceAsyncClient::header_future_heartBeat(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::HBReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_heartBeat, channel_); + heartBeat(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> MetaServiceAsyncClient::header_semifuture_heartBeat(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::HBReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_heartBeat, channel_); + auto callback = std::move(callbackAndFuture.first); + heartBeat(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void MetaServiceAsyncClient::heartBeat(folly::Function callback, const ::nebula::meta::cpp2::HBReq& p_req) { + heartBeat(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper MetaServiceAsyncClient::recv_wrapped_heartBeat( ::nebula::meta::cpp2::HBResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = MetaService_heartBeat_presult; + constexpr auto const fname = "heartBeat"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void MetaServiceAsyncClient::recv_heartBeat( ::nebula::meta::cpp2::HBResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_heartBeat(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void MetaServiceAsyncClient::recv_instance_heartBeat( ::nebula::meta::cpp2::HBResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_heartBeat(_return, state); +} + +folly::exception_wrapper MetaServiceAsyncClient::recv_instance_wrapped_heartBeat( ::nebula::meta::cpp2::HBResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_heartBeat(_return, state); +} + +void MetaServiceAsyncClient::balance(std::unique_ptr callback, const ::nebula::meta::cpp2::BalanceReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + balance(rpcOptions, std::move(callback), p_req); +} + +void MetaServiceAsyncClient::balance(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::BalanceReq& p_req) { + auto ctx = balanceCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + balanceImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void MetaServiceAsyncClient::balanceImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::BalanceReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + balanceT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + balanceT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> MetaServiceAsyncClient::balanceCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "MetaService.balance"); +} + +void MetaServiceAsyncClient::sync_balance( ::nebula::meta::cpp2::BalanceResp& _return, const ::nebula::meta::cpp2::BalanceReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_balance(rpcOptions, _return, p_req); +} + +void MetaServiceAsyncClient::sync_balance(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::BalanceResp& _return, const ::nebula::meta::cpp2::BalanceReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = balanceCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + balanceImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_balance(_return, returnState); + }); +} + + +folly::Future< ::nebula::meta::cpp2::BalanceResp> MetaServiceAsyncClient::future_balance(const ::nebula::meta::cpp2::BalanceReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_balance(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::meta::cpp2::BalanceResp> MetaServiceAsyncClient::semifuture_balance(const ::nebula::meta::cpp2::BalanceReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_balance(rpcOptions, p_req); +} + +folly::Future< ::nebula::meta::cpp2::BalanceResp> MetaServiceAsyncClient::future_balance(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::BalanceReq& p_req) { + folly::Promise< ::nebula::meta::cpp2::BalanceResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_balance, channel_); + balance(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::meta::cpp2::BalanceResp> MetaServiceAsyncClient::semifuture_balance(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::BalanceReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_balance, channel_); + auto callback = std::move(callbackAndFuture.first); + balance(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> MetaServiceAsyncClient::header_future_balance(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::BalanceReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_balance, channel_); + balance(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> MetaServiceAsyncClient::header_semifuture_balance(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::BalanceReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_balance, channel_); + auto callback = std::move(callbackAndFuture.first); + balance(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void MetaServiceAsyncClient::balance(folly::Function callback, const ::nebula::meta::cpp2::BalanceReq& p_req) { + balance(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper MetaServiceAsyncClient::recv_wrapped_balance( ::nebula::meta::cpp2::BalanceResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = MetaService_balance_presult; + constexpr auto const fname = "balance"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void MetaServiceAsyncClient::recv_balance( ::nebula::meta::cpp2::BalanceResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_balance(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void MetaServiceAsyncClient::recv_instance_balance( ::nebula::meta::cpp2::BalanceResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_balance(_return, state); +} + +folly::exception_wrapper MetaServiceAsyncClient::recv_instance_wrapped_balance( ::nebula::meta::cpp2::BalanceResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_balance(_return, state); +} + +void MetaServiceAsyncClient::leaderBalance(std::unique_ptr callback, const ::nebula::meta::cpp2::LeaderBalanceReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + leaderBalance(rpcOptions, std::move(callback), p_req); +} + +void MetaServiceAsyncClient::leaderBalance(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::LeaderBalanceReq& p_req) { + auto ctx = leaderBalanceCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + leaderBalanceImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void MetaServiceAsyncClient::leaderBalanceImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::LeaderBalanceReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + leaderBalanceT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + leaderBalanceT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> MetaServiceAsyncClient::leaderBalanceCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "MetaService.leaderBalance"); +} + +void MetaServiceAsyncClient::sync_leaderBalance( ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::LeaderBalanceReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_leaderBalance(rpcOptions, _return, p_req); +} + +void MetaServiceAsyncClient::sync_leaderBalance(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::LeaderBalanceReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = leaderBalanceCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + leaderBalanceImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_leaderBalance(_return, returnState); + }); +} + + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::future_leaderBalance(const ::nebula::meta::cpp2::LeaderBalanceReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_leaderBalance(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::semifuture_leaderBalance(const ::nebula::meta::cpp2::LeaderBalanceReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_leaderBalance(rpcOptions, p_req); +} + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::future_leaderBalance(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::LeaderBalanceReq& p_req) { + folly::Promise< ::nebula::meta::cpp2::ExecResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_leaderBalance, channel_); + leaderBalance(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::semifuture_leaderBalance(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::LeaderBalanceReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_leaderBalance, channel_); + auto callback = std::move(callbackAndFuture.first); + leaderBalance(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> MetaServiceAsyncClient::header_future_leaderBalance(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::LeaderBalanceReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_leaderBalance, channel_); + leaderBalance(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> MetaServiceAsyncClient::header_semifuture_leaderBalance(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::LeaderBalanceReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_leaderBalance, channel_); + auto callback = std::move(callbackAndFuture.first); + leaderBalance(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void MetaServiceAsyncClient::leaderBalance(folly::Function callback, const ::nebula::meta::cpp2::LeaderBalanceReq& p_req) { + leaderBalance(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper MetaServiceAsyncClient::recv_wrapped_leaderBalance( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = MetaService_leaderBalance_presult; + constexpr auto const fname = "leaderBalance"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void MetaServiceAsyncClient::recv_leaderBalance( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_leaderBalance(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void MetaServiceAsyncClient::recv_instance_leaderBalance( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_leaderBalance(_return, state); +} + +folly::exception_wrapper MetaServiceAsyncClient::recv_instance_wrapped_leaderBalance( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_leaderBalance(_return, state); +} + +void MetaServiceAsyncClient::regConfig(std::unique_ptr callback, const ::nebula::meta::cpp2::RegConfigReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + regConfig(rpcOptions, std::move(callback), p_req); +} + +void MetaServiceAsyncClient::regConfig(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::RegConfigReq& p_req) { + auto ctx = regConfigCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + regConfigImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void MetaServiceAsyncClient::regConfigImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::RegConfigReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + regConfigT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + regConfigT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> MetaServiceAsyncClient::regConfigCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "MetaService.regConfig"); +} + +void MetaServiceAsyncClient::sync_regConfig( ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::RegConfigReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_regConfig(rpcOptions, _return, p_req); +} + +void MetaServiceAsyncClient::sync_regConfig(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::RegConfigReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = regConfigCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + regConfigImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_regConfig(_return, returnState); + }); +} + + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::future_regConfig(const ::nebula::meta::cpp2::RegConfigReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_regConfig(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::semifuture_regConfig(const ::nebula::meta::cpp2::RegConfigReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_regConfig(rpcOptions, p_req); +} + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::future_regConfig(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::RegConfigReq& p_req) { + folly::Promise< ::nebula::meta::cpp2::ExecResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_regConfig, channel_); + regConfig(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::semifuture_regConfig(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::RegConfigReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_regConfig, channel_); + auto callback = std::move(callbackAndFuture.first); + regConfig(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> MetaServiceAsyncClient::header_future_regConfig(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::RegConfigReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_regConfig, channel_); + regConfig(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> MetaServiceAsyncClient::header_semifuture_regConfig(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::RegConfigReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_regConfig, channel_); + auto callback = std::move(callbackAndFuture.first); + regConfig(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void MetaServiceAsyncClient::regConfig(folly::Function callback, const ::nebula::meta::cpp2::RegConfigReq& p_req) { + regConfig(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper MetaServiceAsyncClient::recv_wrapped_regConfig( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = MetaService_regConfig_presult; + constexpr auto const fname = "regConfig"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void MetaServiceAsyncClient::recv_regConfig( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_regConfig(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void MetaServiceAsyncClient::recv_instance_regConfig( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_regConfig(_return, state); +} + +folly::exception_wrapper MetaServiceAsyncClient::recv_instance_wrapped_regConfig( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_regConfig(_return, state); +} + +void MetaServiceAsyncClient::getConfig(std::unique_ptr callback, const ::nebula::meta::cpp2::GetConfigReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + getConfig(rpcOptions, std::move(callback), p_req); +} + +void MetaServiceAsyncClient::getConfig(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::GetConfigReq& p_req) { + auto ctx = getConfigCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + getConfigImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void MetaServiceAsyncClient::getConfigImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::GetConfigReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + getConfigT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + getConfigT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> MetaServiceAsyncClient::getConfigCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "MetaService.getConfig"); +} + +void MetaServiceAsyncClient::sync_getConfig( ::nebula::meta::cpp2::GetConfigResp& _return, const ::nebula::meta::cpp2::GetConfigReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_getConfig(rpcOptions, _return, p_req); +} + +void MetaServiceAsyncClient::sync_getConfig(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::GetConfigResp& _return, const ::nebula::meta::cpp2::GetConfigReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = getConfigCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + getConfigImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_getConfig(_return, returnState); + }); +} + + +folly::Future< ::nebula::meta::cpp2::GetConfigResp> MetaServiceAsyncClient::future_getConfig(const ::nebula::meta::cpp2::GetConfigReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_getConfig(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::meta::cpp2::GetConfigResp> MetaServiceAsyncClient::semifuture_getConfig(const ::nebula::meta::cpp2::GetConfigReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_getConfig(rpcOptions, p_req); +} + +folly::Future< ::nebula::meta::cpp2::GetConfigResp> MetaServiceAsyncClient::future_getConfig(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetConfigReq& p_req) { + folly::Promise< ::nebula::meta::cpp2::GetConfigResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_getConfig, channel_); + getConfig(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::meta::cpp2::GetConfigResp> MetaServiceAsyncClient::semifuture_getConfig(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetConfigReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_getConfig, channel_); + auto callback = std::move(callbackAndFuture.first); + getConfig(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> MetaServiceAsyncClient::header_future_getConfig(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetConfigReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_getConfig, channel_); + getConfig(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> MetaServiceAsyncClient::header_semifuture_getConfig(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetConfigReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_getConfig, channel_); + auto callback = std::move(callbackAndFuture.first); + getConfig(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void MetaServiceAsyncClient::getConfig(folly::Function callback, const ::nebula::meta::cpp2::GetConfigReq& p_req) { + getConfig(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper MetaServiceAsyncClient::recv_wrapped_getConfig( ::nebula::meta::cpp2::GetConfigResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = MetaService_getConfig_presult; + constexpr auto const fname = "getConfig"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void MetaServiceAsyncClient::recv_getConfig( ::nebula::meta::cpp2::GetConfigResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_getConfig(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void MetaServiceAsyncClient::recv_instance_getConfig( ::nebula::meta::cpp2::GetConfigResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_getConfig(_return, state); +} + +folly::exception_wrapper MetaServiceAsyncClient::recv_instance_wrapped_getConfig( ::nebula::meta::cpp2::GetConfigResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_getConfig(_return, state); +} + +void MetaServiceAsyncClient::setConfig(std::unique_ptr callback, const ::nebula::meta::cpp2::SetConfigReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + setConfig(rpcOptions, std::move(callback), p_req); +} + +void MetaServiceAsyncClient::setConfig(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::SetConfigReq& p_req) { + auto ctx = setConfigCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + setConfigImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void MetaServiceAsyncClient::setConfigImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::SetConfigReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + setConfigT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + setConfigT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> MetaServiceAsyncClient::setConfigCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "MetaService.setConfig"); +} + +void MetaServiceAsyncClient::sync_setConfig( ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::SetConfigReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_setConfig(rpcOptions, _return, p_req); +} + +void MetaServiceAsyncClient::sync_setConfig(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::SetConfigReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = setConfigCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + setConfigImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_setConfig(_return, returnState); + }); +} + + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::future_setConfig(const ::nebula::meta::cpp2::SetConfigReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_setConfig(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::semifuture_setConfig(const ::nebula::meta::cpp2::SetConfigReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_setConfig(rpcOptions, p_req); +} + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::future_setConfig(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::SetConfigReq& p_req) { + folly::Promise< ::nebula::meta::cpp2::ExecResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_setConfig, channel_); + setConfig(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::semifuture_setConfig(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::SetConfigReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_setConfig, channel_); + auto callback = std::move(callbackAndFuture.first); + setConfig(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> MetaServiceAsyncClient::header_future_setConfig(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::SetConfigReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_setConfig, channel_); + setConfig(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> MetaServiceAsyncClient::header_semifuture_setConfig(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::SetConfigReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_setConfig, channel_); + auto callback = std::move(callbackAndFuture.first); + setConfig(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void MetaServiceAsyncClient::setConfig(folly::Function callback, const ::nebula::meta::cpp2::SetConfigReq& p_req) { + setConfig(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper MetaServiceAsyncClient::recv_wrapped_setConfig( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = MetaService_setConfig_presult; + constexpr auto const fname = "setConfig"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void MetaServiceAsyncClient::recv_setConfig( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_setConfig(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void MetaServiceAsyncClient::recv_instance_setConfig( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_setConfig(_return, state); +} + +folly::exception_wrapper MetaServiceAsyncClient::recv_instance_wrapped_setConfig( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_setConfig(_return, state); +} + +void MetaServiceAsyncClient::listConfigs(std::unique_ptr callback, const ::nebula::meta::cpp2::ListConfigsReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + listConfigs(rpcOptions, std::move(callback), p_req); +} + +void MetaServiceAsyncClient::listConfigs(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::ListConfigsReq& p_req) { + auto ctx = listConfigsCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + listConfigsImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void MetaServiceAsyncClient::listConfigsImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::ListConfigsReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + listConfigsT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + listConfigsT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> MetaServiceAsyncClient::listConfigsCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "MetaService.listConfigs"); +} + +void MetaServiceAsyncClient::sync_listConfigs( ::nebula::meta::cpp2::ListConfigsResp& _return, const ::nebula::meta::cpp2::ListConfigsReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_listConfigs(rpcOptions, _return, p_req); +} + +void MetaServiceAsyncClient::sync_listConfigs(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ListConfigsResp& _return, const ::nebula::meta::cpp2::ListConfigsReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = listConfigsCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + listConfigsImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_listConfigs(_return, returnState); + }); +} + + +folly::Future< ::nebula::meta::cpp2::ListConfigsResp> MetaServiceAsyncClient::future_listConfigs(const ::nebula::meta::cpp2::ListConfigsReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_listConfigs(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ListConfigsResp> MetaServiceAsyncClient::semifuture_listConfigs(const ::nebula::meta::cpp2::ListConfigsReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_listConfigs(rpcOptions, p_req); +} + +folly::Future< ::nebula::meta::cpp2::ListConfigsResp> MetaServiceAsyncClient::future_listConfigs(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListConfigsReq& p_req) { + folly::Promise< ::nebula::meta::cpp2::ListConfigsResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_listConfigs, channel_); + listConfigs(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::meta::cpp2::ListConfigsResp> MetaServiceAsyncClient::semifuture_listConfigs(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListConfigsReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_listConfigs, channel_); + auto callback = std::move(callbackAndFuture.first); + listConfigs(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> MetaServiceAsyncClient::header_future_listConfigs(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListConfigsReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_listConfigs, channel_); + listConfigs(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> MetaServiceAsyncClient::header_semifuture_listConfigs(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListConfigsReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_listConfigs, channel_); + auto callback = std::move(callbackAndFuture.first); + listConfigs(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void MetaServiceAsyncClient::listConfigs(folly::Function callback, const ::nebula::meta::cpp2::ListConfigsReq& p_req) { + listConfigs(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper MetaServiceAsyncClient::recv_wrapped_listConfigs( ::nebula::meta::cpp2::ListConfigsResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = MetaService_listConfigs_presult; + constexpr auto const fname = "listConfigs"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void MetaServiceAsyncClient::recv_listConfigs( ::nebula::meta::cpp2::ListConfigsResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_listConfigs(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void MetaServiceAsyncClient::recv_instance_listConfigs( ::nebula::meta::cpp2::ListConfigsResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_listConfigs(_return, state); +} + +folly::exception_wrapper MetaServiceAsyncClient::recv_instance_wrapped_listConfigs( ::nebula::meta::cpp2::ListConfigsResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_listConfigs(_return, state); +} + +void MetaServiceAsyncClient::createSnapshot(std::unique_ptr callback, const ::nebula::meta::cpp2::CreateSnapshotReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + createSnapshot(rpcOptions, std::move(callback), p_req); +} + +void MetaServiceAsyncClient::createSnapshot(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::CreateSnapshotReq& p_req) { + auto ctx = createSnapshotCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + createSnapshotImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void MetaServiceAsyncClient::createSnapshotImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::CreateSnapshotReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + createSnapshotT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + createSnapshotT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> MetaServiceAsyncClient::createSnapshotCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "MetaService.createSnapshot"); +} + +void MetaServiceAsyncClient::sync_createSnapshot( ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::CreateSnapshotReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_createSnapshot(rpcOptions, _return, p_req); +} + +void MetaServiceAsyncClient::sync_createSnapshot(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::CreateSnapshotReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = createSnapshotCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + createSnapshotImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_createSnapshot(_return, returnState); + }); +} + + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::future_createSnapshot(const ::nebula::meta::cpp2::CreateSnapshotReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_createSnapshot(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::semifuture_createSnapshot(const ::nebula::meta::cpp2::CreateSnapshotReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_createSnapshot(rpcOptions, p_req); +} + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::future_createSnapshot(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateSnapshotReq& p_req) { + folly::Promise< ::nebula::meta::cpp2::ExecResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_createSnapshot, channel_); + createSnapshot(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::semifuture_createSnapshot(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateSnapshotReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_createSnapshot, channel_); + auto callback = std::move(callbackAndFuture.first); + createSnapshot(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> MetaServiceAsyncClient::header_future_createSnapshot(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateSnapshotReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_createSnapshot, channel_); + createSnapshot(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> MetaServiceAsyncClient::header_semifuture_createSnapshot(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateSnapshotReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_createSnapshot, channel_); + auto callback = std::move(callbackAndFuture.first); + createSnapshot(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void MetaServiceAsyncClient::createSnapshot(folly::Function callback, const ::nebula::meta::cpp2::CreateSnapshotReq& p_req) { + createSnapshot(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper MetaServiceAsyncClient::recv_wrapped_createSnapshot( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = MetaService_createSnapshot_presult; + constexpr auto const fname = "createSnapshot"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void MetaServiceAsyncClient::recv_createSnapshot( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_createSnapshot(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void MetaServiceAsyncClient::recv_instance_createSnapshot( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_createSnapshot(_return, state); +} + +folly::exception_wrapper MetaServiceAsyncClient::recv_instance_wrapped_createSnapshot( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_createSnapshot(_return, state); +} + +void MetaServiceAsyncClient::dropSnapshot(std::unique_ptr callback, const ::nebula::meta::cpp2::DropSnapshotReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + dropSnapshot(rpcOptions, std::move(callback), p_req); +} + +void MetaServiceAsyncClient::dropSnapshot(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::DropSnapshotReq& p_req) { + auto ctx = dropSnapshotCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + dropSnapshotImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void MetaServiceAsyncClient::dropSnapshotImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::DropSnapshotReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + dropSnapshotT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + dropSnapshotT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> MetaServiceAsyncClient::dropSnapshotCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "MetaService.dropSnapshot"); +} + +void MetaServiceAsyncClient::sync_dropSnapshot( ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::DropSnapshotReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_dropSnapshot(rpcOptions, _return, p_req); +} + +void MetaServiceAsyncClient::sync_dropSnapshot(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::DropSnapshotReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = dropSnapshotCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + dropSnapshotImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_dropSnapshot(_return, returnState); + }); +} + + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::future_dropSnapshot(const ::nebula::meta::cpp2::DropSnapshotReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_dropSnapshot(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::semifuture_dropSnapshot(const ::nebula::meta::cpp2::DropSnapshotReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_dropSnapshot(rpcOptions, p_req); +} + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::future_dropSnapshot(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropSnapshotReq& p_req) { + folly::Promise< ::nebula::meta::cpp2::ExecResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_dropSnapshot, channel_); + dropSnapshot(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::semifuture_dropSnapshot(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropSnapshotReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_dropSnapshot, channel_); + auto callback = std::move(callbackAndFuture.first); + dropSnapshot(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> MetaServiceAsyncClient::header_future_dropSnapshot(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropSnapshotReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_dropSnapshot, channel_); + dropSnapshot(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> MetaServiceAsyncClient::header_semifuture_dropSnapshot(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropSnapshotReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_dropSnapshot, channel_); + auto callback = std::move(callbackAndFuture.first); + dropSnapshot(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void MetaServiceAsyncClient::dropSnapshot(folly::Function callback, const ::nebula::meta::cpp2::DropSnapshotReq& p_req) { + dropSnapshot(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper MetaServiceAsyncClient::recv_wrapped_dropSnapshot( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = MetaService_dropSnapshot_presult; + constexpr auto const fname = "dropSnapshot"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void MetaServiceAsyncClient::recv_dropSnapshot( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_dropSnapshot(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void MetaServiceAsyncClient::recv_instance_dropSnapshot( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_dropSnapshot(_return, state); +} + +folly::exception_wrapper MetaServiceAsyncClient::recv_instance_wrapped_dropSnapshot( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_dropSnapshot(_return, state); +} + +void MetaServiceAsyncClient::listSnapshots(std::unique_ptr callback, const ::nebula::meta::cpp2::ListSnapshotsReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + listSnapshots(rpcOptions, std::move(callback), p_req); +} + +void MetaServiceAsyncClient::listSnapshots(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::ListSnapshotsReq& p_req) { + auto ctx = listSnapshotsCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + listSnapshotsImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void MetaServiceAsyncClient::listSnapshotsImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::ListSnapshotsReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + listSnapshotsT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + listSnapshotsT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> MetaServiceAsyncClient::listSnapshotsCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "MetaService.listSnapshots"); +} + +void MetaServiceAsyncClient::sync_listSnapshots( ::nebula::meta::cpp2::ListSnapshotsResp& _return, const ::nebula::meta::cpp2::ListSnapshotsReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_listSnapshots(rpcOptions, _return, p_req); +} + +void MetaServiceAsyncClient::sync_listSnapshots(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ListSnapshotsResp& _return, const ::nebula::meta::cpp2::ListSnapshotsReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = listSnapshotsCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + listSnapshotsImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_listSnapshots(_return, returnState); + }); +} + + +folly::Future< ::nebula::meta::cpp2::ListSnapshotsResp> MetaServiceAsyncClient::future_listSnapshots(const ::nebula::meta::cpp2::ListSnapshotsReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_listSnapshots(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ListSnapshotsResp> MetaServiceAsyncClient::semifuture_listSnapshots(const ::nebula::meta::cpp2::ListSnapshotsReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_listSnapshots(rpcOptions, p_req); +} + +folly::Future< ::nebula::meta::cpp2::ListSnapshotsResp> MetaServiceAsyncClient::future_listSnapshots(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListSnapshotsReq& p_req) { + folly::Promise< ::nebula::meta::cpp2::ListSnapshotsResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_listSnapshots, channel_); + listSnapshots(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::meta::cpp2::ListSnapshotsResp> MetaServiceAsyncClient::semifuture_listSnapshots(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListSnapshotsReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_listSnapshots, channel_); + auto callback = std::move(callbackAndFuture.first); + listSnapshots(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> MetaServiceAsyncClient::header_future_listSnapshots(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListSnapshotsReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_listSnapshots, channel_); + listSnapshots(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> MetaServiceAsyncClient::header_semifuture_listSnapshots(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListSnapshotsReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_listSnapshots, channel_); + auto callback = std::move(callbackAndFuture.first); + listSnapshots(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void MetaServiceAsyncClient::listSnapshots(folly::Function callback, const ::nebula::meta::cpp2::ListSnapshotsReq& p_req) { + listSnapshots(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper MetaServiceAsyncClient::recv_wrapped_listSnapshots( ::nebula::meta::cpp2::ListSnapshotsResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = MetaService_listSnapshots_presult; + constexpr auto const fname = "listSnapshots"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void MetaServiceAsyncClient::recv_listSnapshots( ::nebula::meta::cpp2::ListSnapshotsResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_listSnapshots(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void MetaServiceAsyncClient::recv_instance_listSnapshots( ::nebula::meta::cpp2::ListSnapshotsResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_listSnapshots(_return, state); +} + +folly::exception_wrapper MetaServiceAsyncClient::recv_instance_wrapped_listSnapshots( ::nebula::meta::cpp2::ListSnapshotsResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_listSnapshots(_return, state); +} + +void MetaServiceAsyncClient::runAdminJob(std::unique_ptr callback, const ::nebula::meta::cpp2::AdminJobReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + runAdminJob(rpcOptions, std::move(callback), p_req); +} + +void MetaServiceAsyncClient::runAdminJob(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::AdminJobReq& p_req) { + auto ctx = runAdminJobCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + runAdminJobImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void MetaServiceAsyncClient::runAdminJobImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::AdminJobReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + runAdminJobT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + runAdminJobT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> MetaServiceAsyncClient::runAdminJobCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "MetaService.runAdminJob"); +} + +void MetaServiceAsyncClient::sync_runAdminJob( ::nebula::meta::cpp2::AdminJobResp& _return, const ::nebula::meta::cpp2::AdminJobReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_runAdminJob(rpcOptions, _return, p_req); +} + +void MetaServiceAsyncClient::sync_runAdminJob(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::AdminJobResp& _return, const ::nebula::meta::cpp2::AdminJobReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = runAdminJobCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + runAdminJobImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_runAdminJob(_return, returnState); + }); +} + + +folly::Future< ::nebula::meta::cpp2::AdminJobResp> MetaServiceAsyncClient::future_runAdminJob(const ::nebula::meta::cpp2::AdminJobReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_runAdminJob(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::meta::cpp2::AdminJobResp> MetaServiceAsyncClient::semifuture_runAdminJob(const ::nebula::meta::cpp2::AdminJobReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_runAdminJob(rpcOptions, p_req); +} + +folly::Future< ::nebula::meta::cpp2::AdminJobResp> MetaServiceAsyncClient::future_runAdminJob(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::AdminJobReq& p_req) { + folly::Promise< ::nebula::meta::cpp2::AdminJobResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_runAdminJob, channel_); + runAdminJob(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::meta::cpp2::AdminJobResp> MetaServiceAsyncClient::semifuture_runAdminJob(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::AdminJobReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_runAdminJob, channel_); + auto callback = std::move(callbackAndFuture.first); + runAdminJob(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> MetaServiceAsyncClient::header_future_runAdminJob(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::AdminJobReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_runAdminJob, channel_); + runAdminJob(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> MetaServiceAsyncClient::header_semifuture_runAdminJob(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::AdminJobReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_runAdminJob, channel_); + auto callback = std::move(callbackAndFuture.first); + runAdminJob(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void MetaServiceAsyncClient::runAdminJob(folly::Function callback, const ::nebula::meta::cpp2::AdminJobReq& p_req) { + runAdminJob(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper MetaServiceAsyncClient::recv_wrapped_runAdminJob( ::nebula::meta::cpp2::AdminJobResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = MetaService_runAdminJob_presult; + constexpr auto const fname = "runAdminJob"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void MetaServiceAsyncClient::recv_runAdminJob( ::nebula::meta::cpp2::AdminJobResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_runAdminJob(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void MetaServiceAsyncClient::recv_instance_runAdminJob( ::nebula::meta::cpp2::AdminJobResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_runAdminJob(_return, state); +} + +folly::exception_wrapper MetaServiceAsyncClient::recv_instance_wrapped_runAdminJob( ::nebula::meta::cpp2::AdminJobResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_runAdminJob(_return, state); +} + +void MetaServiceAsyncClient::addZone(std::unique_ptr callback, const ::nebula::meta::cpp2::AddZoneReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + addZone(rpcOptions, std::move(callback), p_req); +} + +void MetaServiceAsyncClient::addZone(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::AddZoneReq& p_req) { + auto ctx = addZoneCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + addZoneImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void MetaServiceAsyncClient::addZoneImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::AddZoneReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + addZoneT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + addZoneT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> MetaServiceAsyncClient::addZoneCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "MetaService.addZone"); +} + +void MetaServiceAsyncClient::sync_addZone( ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::AddZoneReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_addZone(rpcOptions, _return, p_req); +} + +void MetaServiceAsyncClient::sync_addZone(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::AddZoneReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = addZoneCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + addZoneImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_addZone(_return, returnState); + }); +} + + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::future_addZone(const ::nebula::meta::cpp2::AddZoneReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_addZone(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::semifuture_addZone(const ::nebula::meta::cpp2::AddZoneReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_addZone(rpcOptions, p_req); +} + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::future_addZone(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::AddZoneReq& p_req) { + folly::Promise< ::nebula::meta::cpp2::ExecResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_addZone, channel_); + addZone(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::semifuture_addZone(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::AddZoneReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_addZone, channel_); + auto callback = std::move(callbackAndFuture.first); + addZone(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> MetaServiceAsyncClient::header_future_addZone(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::AddZoneReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_addZone, channel_); + addZone(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> MetaServiceAsyncClient::header_semifuture_addZone(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::AddZoneReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_addZone, channel_); + auto callback = std::move(callbackAndFuture.first); + addZone(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void MetaServiceAsyncClient::addZone(folly::Function callback, const ::nebula::meta::cpp2::AddZoneReq& p_req) { + addZone(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper MetaServiceAsyncClient::recv_wrapped_addZone( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = MetaService_addZone_presult; + constexpr auto const fname = "addZone"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void MetaServiceAsyncClient::recv_addZone( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_addZone(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void MetaServiceAsyncClient::recv_instance_addZone( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_addZone(_return, state); +} + +folly::exception_wrapper MetaServiceAsyncClient::recv_instance_wrapped_addZone( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_addZone(_return, state); +} + +void MetaServiceAsyncClient::dropZone(std::unique_ptr callback, const ::nebula::meta::cpp2::DropZoneReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + dropZone(rpcOptions, std::move(callback), p_req); +} + +void MetaServiceAsyncClient::dropZone(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::DropZoneReq& p_req) { + auto ctx = dropZoneCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + dropZoneImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void MetaServiceAsyncClient::dropZoneImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::DropZoneReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + dropZoneT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + dropZoneT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> MetaServiceAsyncClient::dropZoneCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "MetaService.dropZone"); +} + +void MetaServiceAsyncClient::sync_dropZone( ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::DropZoneReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_dropZone(rpcOptions, _return, p_req); +} + +void MetaServiceAsyncClient::sync_dropZone(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::DropZoneReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = dropZoneCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + dropZoneImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_dropZone(_return, returnState); + }); +} + + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::future_dropZone(const ::nebula::meta::cpp2::DropZoneReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_dropZone(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::semifuture_dropZone(const ::nebula::meta::cpp2::DropZoneReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_dropZone(rpcOptions, p_req); +} + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::future_dropZone(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropZoneReq& p_req) { + folly::Promise< ::nebula::meta::cpp2::ExecResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_dropZone, channel_); + dropZone(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::semifuture_dropZone(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropZoneReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_dropZone, channel_); + auto callback = std::move(callbackAndFuture.first); + dropZone(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> MetaServiceAsyncClient::header_future_dropZone(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropZoneReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_dropZone, channel_); + dropZone(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> MetaServiceAsyncClient::header_semifuture_dropZone(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropZoneReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_dropZone, channel_); + auto callback = std::move(callbackAndFuture.first); + dropZone(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void MetaServiceAsyncClient::dropZone(folly::Function callback, const ::nebula::meta::cpp2::DropZoneReq& p_req) { + dropZone(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper MetaServiceAsyncClient::recv_wrapped_dropZone( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = MetaService_dropZone_presult; + constexpr auto const fname = "dropZone"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void MetaServiceAsyncClient::recv_dropZone( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_dropZone(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void MetaServiceAsyncClient::recv_instance_dropZone( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_dropZone(_return, state); +} + +folly::exception_wrapper MetaServiceAsyncClient::recv_instance_wrapped_dropZone( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_dropZone(_return, state); +} + +void MetaServiceAsyncClient::addHostIntoZone(std::unique_ptr callback, const ::nebula::meta::cpp2::AddHostIntoZoneReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + addHostIntoZone(rpcOptions, std::move(callback), p_req); +} + +void MetaServiceAsyncClient::addHostIntoZone(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::AddHostIntoZoneReq& p_req) { + auto ctx = addHostIntoZoneCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + addHostIntoZoneImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void MetaServiceAsyncClient::addHostIntoZoneImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::AddHostIntoZoneReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + addHostIntoZoneT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + addHostIntoZoneT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> MetaServiceAsyncClient::addHostIntoZoneCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "MetaService.addHostIntoZone"); +} + +void MetaServiceAsyncClient::sync_addHostIntoZone( ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::AddHostIntoZoneReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_addHostIntoZone(rpcOptions, _return, p_req); +} + +void MetaServiceAsyncClient::sync_addHostIntoZone(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::AddHostIntoZoneReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = addHostIntoZoneCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + addHostIntoZoneImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_addHostIntoZone(_return, returnState); + }); +} + + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::future_addHostIntoZone(const ::nebula::meta::cpp2::AddHostIntoZoneReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_addHostIntoZone(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::semifuture_addHostIntoZone(const ::nebula::meta::cpp2::AddHostIntoZoneReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_addHostIntoZone(rpcOptions, p_req); +} + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::future_addHostIntoZone(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::AddHostIntoZoneReq& p_req) { + folly::Promise< ::nebula::meta::cpp2::ExecResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_addHostIntoZone, channel_); + addHostIntoZone(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::semifuture_addHostIntoZone(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::AddHostIntoZoneReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_addHostIntoZone, channel_); + auto callback = std::move(callbackAndFuture.first); + addHostIntoZone(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> MetaServiceAsyncClient::header_future_addHostIntoZone(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::AddHostIntoZoneReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_addHostIntoZone, channel_); + addHostIntoZone(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> MetaServiceAsyncClient::header_semifuture_addHostIntoZone(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::AddHostIntoZoneReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_addHostIntoZone, channel_); + auto callback = std::move(callbackAndFuture.first); + addHostIntoZone(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void MetaServiceAsyncClient::addHostIntoZone(folly::Function callback, const ::nebula::meta::cpp2::AddHostIntoZoneReq& p_req) { + addHostIntoZone(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper MetaServiceAsyncClient::recv_wrapped_addHostIntoZone( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = MetaService_addHostIntoZone_presult; + constexpr auto const fname = "addHostIntoZone"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void MetaServiceAsyncClient::recv_addHostIntoZone( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_addHostIntoZone(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void MetaServiceAsyncClient::recv_instance_addHostIntoZone( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_addHostIntoZone(_return, state); +} + +folly::exception_wrapper MetaServiceAsyncClient::recv_instance_wrapped_addHostIntoZone( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_addHostIntoZone(_return, state); +} + +void MetaServiceAsyncClient::dropHostFromZone(std::unique_ptr callback, const ::nebula::meta::cpp2::DropHostFromZoneReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + dropHostFromZone(rpcOptions, std::move(callback), p_req); +} + +void MetaServiceAsyncClient::dropHostFromZone(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::DropHostFromZoneReq& p_req) { + auto ctx = dropHostFromZoneCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + dropHostFromZoneImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void MetaServiceAsyncClient::dropHostFromZoneImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::DropHostFromZoneReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + dropHostFromZoneT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + dropHostFromZoneT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> MetaServiceAsyncClient::dropHostFromZoneCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "MetaService.dropHostFromZone"); +} + +void MetaServiceAsyncClient::sync_dropHostFromZone( ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::DropHostFromZoneReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_dropHostFromZone(rpcOptions, _return, p_req); +} + +void MetaServiceAsyncClient::sync_dropHostFromZone(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::DropHostFromZoneReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = dropHostFromZoneCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + dropHostFromZoneImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_dropHostFromZone(_return, returnState); + }); +} + + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::future_dropHostFromZone(const ::nebula::meta::cpp2::DropHostFromZoneReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_dropHostFromZone(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::semifuture_dropHostFromZone(const ::nebula::meta::cpp2::DropHostFromZoneReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_dropHostFromZone(rpcOptions, p_req); +} + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::future_dropHostFromZone(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropHostFromZoneReq& p_req) { + folly::Promise< ::nebula::meta::cpp2::ExecResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_dropHostFromZone, channel_); + dropHostFromZone(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::semifuture_dropHostFromZone(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropHostFromZoneReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_dropHostFromZone, channel_); + auto callback = std::move(callbackAndFuture.first); + dropHostFromZone(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> MetaServiceAsyncClient::header_future_dropHostFromZone(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropHostFromZoneReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_dropHostFromZone, channel_); + dropHostFromZone(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> MetaServiceAsyncClient::header_semifuture_dropHostFromZone(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropHostFromZoneReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_dropHostFromZone, channel_); + auto callback = std::move(callbackAndFuture.first); + dropHostFromZone(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void MetaServiceAsyncClient::dropHostFromZone(folly::Function callback, const ::nebula::meta::cpp2::DropHostFromZoneReq& p_req) { + dropHostFromZone(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper MetaServiceAsyncClient::recv_wrapped_dropHostFromZone( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = MetaService_dropHostFromZone_presult; + constexpr auto const fname = "dropHostFromZone"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void MetaServiceAsyncClient::recv_dropHostFromZone( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_dropHostFromZone(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void MetaServiceAsyncClient::recv_instance_dropHostFromZone( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_dropHostFromZone(_return, state); +} + +folly::exception_wrapper MetaServiceAsyncClient::recv_instance_wrapped_dropHostFromZone( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_dropHostFromZone(_return, state); +} + +void MetaServiceAsyncClient::getZone(std::unique_ptr callback, const ::nebula::meta::cpp2::GetZoneReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + getZone(rpcOptions, std::move(callback), p_req); +} + +void MetaServiceAsyncClient::getZone(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::GetZoneReq& p_req) { + auto ctx = getZoneCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + getZoneImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void MetaServiceAsyncClient::getZoneImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::GetZoneReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + getZoneT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + getZoneT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> MetaServiceAsyncClient::getZoneCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "MetaService.getZone"); +} + +void MetaServiceAsyncClient::sync_getZone( ::nebula::meta::cpp2::GetZoneResp& _return, const ::nebula::meta::cpp2::GetZoneReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_getZone(rpcOptions, _return, p_req); +} + +void MetaServiceAsyncClient::sync_getZone(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::GetZoneResp& _return, const ::nebula::meta::cpp2::GetZoneReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = getZoneCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + getZoneImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_getZone(_return, returnState); + }); +} + + +folly::Future< ::nebula::meta::cpp2::GetZoneResp> MetaServiceAsyncClient::future_getZone(const ::nebula::meta::cpp2::GetZoneReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_getZone(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::meta::cpp2::GetZoneResp> MetaServiceAsyncClient::semifuture_getZone(const ::nebula::meta::cpp2::GetZoneReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_getZone(rpcOptions, p_req); +} + +folly::Future< ::nebula::meta::cpp2::GetZoneResp> MetaServiceAsyncClient::future_getZone(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetZoneReq& p_req) { + folly::Promise< ::nebula::meta::cpp2::GetZoneResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_getZone, channel_); + getZone(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::meta::cpp2::GetZoneResp> MetaServiceAsyncClient::semifuture_getZone(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetZoneReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_getZone, channel_); + auto callback = std::move(callbackAndFuture.first); + getZone(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> MetaServiceAsyncClient::header_future_getZone(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetZoneReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_getZone, channel_); + getZone(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> MetaServiceAsyncClient::header_semifuture_getZone(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetZoneReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_getZone, channel_); + auto callback = std::move(callbackAndFuture.first); + getZone(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void MetaServiceAsyncClient::getZone(folly::Function callback, const ::nebula::meta::cpp2::GetZoneReq& p_req) { + getZone(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper MetaServiceAsyncClient::recv_wrapped_getZone( ::nebula::meta::cpp2::GetZoneResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = MetaService_getZone_presult; + constexpr auto const fname = "getZone"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void MetaServiceAsyncClient::recv_getZone( ::nebula::meta::cpp2::GetZoneResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_getZone(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void MetaServiceAsyncClient::recv_instance_getZone( ::nebula::meta::cpp2::GetZoneResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_getZone(_return, state); +} + +folly::exception_wrapper MetaServiceAsyncClient::recv_instance_wrapped_getZone( ::nebula::meta::cpp2::GetZoneResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_getZone(_return, state); +} + +void MetaServiceAsyncClient::listZones(std::unique_ptr callback, const ::nebula::meta::cpp2::ListZonesReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + listZones(rpcOptions, std::move(callback), p_req); +} + +void MetaServiceAsyncClient::listZones(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::ListZonesReq& p_req) { + auto ctx = listZonesCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + listZonesImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void MetaServiceAsyncClient::listZonesImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::ListZonesReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + listZonesT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + listZonesT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> MetaServiceAsyncClient::listZonesCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "MetaService.listZones"); +} + +void MetaServiceAsyncClient::sync_listZones( ::nebula::meta::cpp2::ListZonesResp& _return, const ::nebula::meta::cpp2::ListZonesReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_listZones(rpcOptions, _return, p_req); +} + +void MetaServiceAsyncClient::sync_listZones(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ListZonesResp& _return, const ::nebula::meta::cpp2::ListZonesReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = listZonesCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + listZonesImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_listZones(_return, returnState); + }); +} + + +folly::Future< ::nebula::meta::cpp2::ListZonesResp> MetaServiceAsyncClient::future_listZones(const ::nebula::meta::cpp2::ListZonesReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_listZones(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ListZonesResp> MetaServiceAsyncClient::semifuture_listZones(const ::nebula::meta::cpp2::ListZonesReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_listZones(rpcOptions, p_req); +} + +folly::Future< ::nebula::meta::cpp2::ListZonesResp> MetaServiceAsyncClient::future_listZones(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListZonesReq& p_req) { + folly::Promise< ::nebula::meta::cpp2::ListZonesResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_listZones, channel_); + listZones(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::meta::cpp2::ListZonesResp> MetaServiceAsyncClient::semifuture_listZones(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListZonesReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_listZones, channel_); + auto callback = std::move(callbackAndFuture.first); + listZones(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> MetaServiceAsyncClient::header_future_listZones(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListZonesReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_listZones, channel_); + listZones(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> MetaServiceAsyncClient::header_semifuture_listZones(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListZonesReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_listZones, channel_); + auto callback = std::move(callbackAndFuture.first); + listZones(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void MetaServiceAsyncClient::listZones(folly::Function callback, const ::nebula::meta::cpp2::ListZonesReq& p_req) { + listZones(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper MetaServiceAsyncClient::recv_wrapped_listZones( ::nebula::meta::cpp2::ListZonesResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = MetaService_listZones_presult; + constexpr auto const fname = "listZones"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void MetaServiceAsyncClient::recv_listZones( ::nebula::meta::cpp2::ListZonesResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_listZones(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void MetaServiceAsyncClient::recv_instance_listZones( ::nebula::meta::cpp2::ListZonesResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_listZones(_return, state); +} + +folly::exception_wrapper MetaServiceAsyncClient::recv_instance_wrapped_listZones( ::nebula::meta::cpp2::ListZonesResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_listZones(_return, state); +} + +void MetaServiceAsyncClient::addGroup(std::unique_ptr callback, const ::nebula::meta::cpp2::AddGroupReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + addGroup(rpcOptions, std::move(callback), p_req); +} + +void MetaServiceAsyncClient::addGroup(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::AddGroupReq& p_req) { + auto ctx = addGroupCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + addGroupImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void MetaServiceAsyncClient::addGroupImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::AddGroupReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + addGroupT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + addGroupT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> MetaServiceAsyncClient::addGroupCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "MetaService.addGroup"); +} + +void MetaServiceAsyncClient::sync_addGroup( ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::AddGroupReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_addGroup(rpcOptions, _return, p_req); +} + +void MetaServiceAsyncClient::sync_addGroup(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::AddGroupReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = addGroupCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + addGroupImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_addGroup(_return, returnState); + }); +} + + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::future_addGroup(const ::nebula::meta::cpp2::AddGroupReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_addGroup(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::semifuture_addGroup(const ::nebula::meta::cpp2::AddGroupReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_addGroup(rpcOptions, p_req); +} + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::future_addGroup(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::AddGroupReq& p_req) { + folly::Promise< ::nebula::meta::cpp2::ExecResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_addGroup, channel_); + addGroup(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::semifuture_addGroup(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::AddGroupReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_addGroup, channel_); + auto callback = std::move(callbackAndFuture.first); + addGroup(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> MetaServiceAsyncClient::header_future_addGroup(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::AddGroupReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_addGroup, channel_); + addGroup(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> MetaServiceAsyncClient::header_semifuture_addGroup(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::AddGroupReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_addGroup, channel_); + auto callback = std::move(callbackAndFuture.first); + addGroup(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void MetaServiceAsyncClient::addGroup(folly::Function callback, const ::nebula::meta::cpp2::AddGroupReq& p_req) { + addGroup(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper MetaServiceAsyncClient::recv_wrapped_addGroup( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = MetaService_addGroup_presult; + constexpr auto const fname = "addGroup"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void MetaServiceAsyncClient::recv_addGroup( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_addGroup(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void MetaServiceAsyncClient::recv_instance_addGroup( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_addGroup(_return, state); +} + +folly::exception_wrapper MetaServiceAsyncClient::recv_instance_wrapped_addGroup( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_addGroup(_return, state); +} + +void MetaServiceAsyncClient::dropGroup(std::unique_ptr callback, const ::nebula::meta::cpp2::DropGroupReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + dropGroup(rpcOptions, std::move(callback), p_req); +} + +void MetaServiceAsyncClient::dropGroup(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::DropGroupReq& p_req) { + auto ctx = dropGroupCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + dropGroupImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void MetaServiceAsyncClient::dropGroupImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::DropGroupReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + dropGroupT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + dropGroupT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> MetaServiceAsyncClient::dropGroupCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "MetaService.dropGroup"); +} + +void MetaServiceAsyncClient::sync_dropGroup( ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::DropGroupReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_dropGroup(rpcOptions, _return, p_req); +} + +void MetaServiceAsyncClient::sync_dropGroup(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::DropGroupReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = dropGroupCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + dropGroupImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_dropGroup(_return, returnState); + }); +} + + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::future_dropGroup(const ::nebula::meta::cpp2::DropGroupReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_dropGroup(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::semifuture_dropGroup(const ::nebula::meta::cpp2::DropGroupReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_dropGroup(rpcOptions, p_req); +} + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::future_dropGroup(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropGroupReq& p_req) { + folly::Promise< ::nebula::meta::cpp2::ExecResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_dropGroup, channel_); + dropGroup(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::semifuture_dropGroup(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropGroupReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_dropGroup, channel_); + auto callback = std::move(callbackAndFuture.first); + dropGroup(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> MetaServiceAsyncClient::header_future_dropGroup(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropGroupReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_dropGroup, channel_); + dropGroup(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> MetaServiceAsyncClient::header_semifuture_dropGroup(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropGroupReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_dropGroup, channel_); + auto callback = std::move(callbackAndFuture.first); + dropGroup(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void MetaServiceAsyncClient::dropGroup(folly::Function callback, const ::nebula::meta::cpp2::DropGroupReq& p_req) { + dropGroup(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper MetaServiceAsyncClient::recv_wrapped_dropGroup( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = MetaService_dropGroup_presult; + constexpr auto const fname = "dropGroup"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void MetaServiceAsyncClient::recv_dropGroup( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_dropGroup(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void MetaServiceAsyncClient::recv_instance_dropGroup( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_dropGroup(_return, state); +} + +folly::exception_wrapper MetaServiceAsyncClient::recv_instance_wrapped_dropGroup( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_dropGroup(_return, state); +} + +void MetaServiceAsyncClient::addZoneIntoGroup(std::unique_ptr callback, const ::nebula::meta::cpp2::AddZoneIntoGroupReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + addZoneIntoGroup(rpcOptions, std::move(callback), p_req); +} + +void MetaServiceAsyncClient::addZoneIntoGroup(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::AddZoneIntoGroupReq& p_req) { + auto ctx = addZoneIntoGroupCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + addZoneIntoGroupImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void MetaServiceAsyncClient::addZoneIntoGroupImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::AddZoneIntoGroupReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + addZoneIntoGroupT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + addZoneIntoGroupT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> MetaServiceAsyncClient::addZoneIntoGroupCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "MetaService.addZoneIntoGroup"); +} + +void MetaServiceAsyncClient::sync_addZoneIntoGroup( ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::AddZoneIntoGroupReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_addZoneIntoGroup(rpcOptions, _return, p_req); +} + +void MetaServiceAsyncClient::sync_addZoneIntoGroup(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::AddZoneIntoGroupReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = addZoneIntoGroupCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + addZoneIntoGroupImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_addZoneIntoGroup(_return, returnState); + }); +} + + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::future_addZoneIntoGroup(const ::nebula::meta::cpp2::AddZoneIntoGroupReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_addZoneIntoGroup(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::semifuture_addZoneIntoGroup(const ::nebula::meta::cpp2::AddZoneIntoGroupReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_addZoneIntoGroup(rpcOptions, p_req); +} + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::future_addZoneIntoGroup(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::AddZoneIntoGroupReq& p_req) { + folly::Promise< ::nebula::meta::cpp2::ExecResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_addZoneIntoGroup, channel_); + addZoneIntoGroup(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::semifuture_addZoneIntoGroup(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::AddZoneIntoGroupReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_addZoneIntoGroup, channel_); + auto callback = std::move(callbackAndFuture.first); + addZoneIntoGroup(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> MetaServiceAsyncClient::header_future_addZoneIntoGroup(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::AddZoneIntoGroupReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_addZoneIntoGroup, channel_); + addZoneIntoGroup(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> MetaServiceAsyncClient::header_semifuture_addZoneIntoGroup(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::AddZoneIntoGroupReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_addZoneIntoGroup, channel_); + auto callback = std::move(callbackAndFuture.first); + addZoneIntoGroup(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void MetaServiceAsyncClient::addZoneIntoGroup(folly::Function callback, const ::nebula::meta::cpp2::AddZoneIntoGroupReq& p_req) { + addZoneIntoGroup(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper MetaServiceAsyncClient::recv_wrapped_addZoneIntoGroup( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = MetaService_addZoneIntoGroup_presult; + constexpr auto const fname = "addZoneIntoGroup"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void MetaServiceAsyncClient::recv_addZoneIntoGroup( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_addZoneIntoGroup(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void MetaServiceAsyncClient::recv_instance_addZoneIntoGroup( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_addZoneIntoGroup(_return, state); +} + +folly::exception_wrapper MetaServiceAsyncClient::recv_instance_wrapped_addZoneIntoGroup( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_addZoneIntoGroup(_return, state); +} + +void MetaServiceAsyncClient::dropZoneFromGroup(std::unique_ptr callback, const ::nebula::meta::cpp2::DropZoneFromGroupReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + dropZoneFromGroup(rpcOptions, std::move(callback), p_req); +} + +void MetaServiceAsyncClient::dropZoneFromGroup(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::DropZoneFromGroupReq& p_req) { + auto ctx = dropZoneFromGroupCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + dropZoneFromGroupImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void MetaServiceAsyncClient::dropZoneFromGroupImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::DropZoneFromGroupReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + dropZoneFromGroupT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + dropZoneFromGroupT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> MetaServiceAsyncClient::dropZoneFromGroupCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "MetaService.dropZoneFromGroup"); +} + +void MetaServiceAsyncClient::sync_dropZoneFromGroup( ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::DropZoneFromGroupReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_dropZoneFromGroup(rpcOptions, _return, p_req); +} + +void MetaServiceAsyncClient::sync_dropZoneFromGroup(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::DropZoneFromGroupReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = dropZoneFromGroupCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + dropZoneFromGroupImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_dropZoneFromGroup(_return, returnState); + }); +} + + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::future_dropZoneFromGroup(const ::nebula::meta::cpp2::DropZoneFromGroupReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_dropZoneFromGroup(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::semifuture_dropZoneFromGroup(const ::nebula::meta::cpp2::DropZoneFromGroupReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_dropZoneFromGroup(rpcOptions, p_req); +} + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::future_dropZoneFromGroup(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropZoneFromGroupReq& p_req) { + folly::Promise< ::nebula::meta::cpp2::ExecResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_dropZoneFromGroup, channel_); + dropZoneFromGroup(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::semifuture_dropZoneFromGroup(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropZoneFromGroupReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_dropZoneFromGroup, channel_); + auto callback = std::move(callbackAndFuture.first); + dropZoneFromGroup(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> MetaServiceAsyncClient::header_future_dropZoneFromGroup(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropZoneFromGroupReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_dropZoneFromGroup, channel_); + dropZoneFromGroup(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> MetaServiceAsyncClient::header_semifuture_dropZoneFromGroup(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropZoneFromGroupReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_dropZoneFromGroup, channel_); + auto callback = std::move(callbackAndFuture.first); + dropZoneFromGroup(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void MetaServiceAsyncClient::dropZoneFromGroup(folly::Function callback, const ::nebula::meta::cpp2::DropZoneFromGroupReq& p_req) { + dropZoneFromGroup(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper MetaServiceAsyncClient::recv_wrapped_dropZoneFromGroup( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = MetaService_dropZoneFromGroup_presult; + constexpr auto const fname = "dropZoneFromGroup"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void MetaServiceAsyncClient::recv_dropZoneFromGroup( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_dropZoneFromGroup(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void MetaServiceAsyncClient::recv_instance_dropZoneFromGroup( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_dropZoneFromGroup(_return, state); +} + +folly::exception_wrapper MetaServiceAsyncClient::recv_instance_wrapped_dropZoneFromGroup( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_dropZoneFromGroup(_return, state); +} + +void MetaServiceAsyncClient::getGroup(std::unique_ptr callback, const ::nebula::meta::cpp2::GetGroupReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + getGroup(rpcOptions, std::move(callback), p_req); +} + +void MetaServiceAsyncClient::getGroup(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::GetGroupReq& p_req) { + auto ctx = getGroupCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + getGroupImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void MetaServiceAsyncClient::getGroupImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::GetGroupReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + getGroupT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + getGroupT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> MetaServiceAsyncClient::getGroupCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "MetaService.getGroup"); +} + +void MetaServiceAsyncClient::sync_getGroup( ::nebula::meta::cpp2::GetGroupResp& _return, const ::nebula::meta::cpp2::GetGroupReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_getGroup(rpcOptions, _return, p_req); +} + +void MetaServiceAsyncClient::sync_getGroup(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::GetGroupResp& _return, const ::nebula::meta::cpp2::GetGroupReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = getGroupCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + getGroupImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_getGroup(_return, returnState); + }); +} + + +folly::Future< ::nebula::meta::cpp2::GetGroupResp> MetaServiceAsyncClient::future_getGroup(const ::nebula::meta::cpp2::GetGroupReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_getGroup(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::meta::cpp2::GetGroupResp> MetaServiceAsyncClient::semifuture_getGroup(const ::nebula::meta::cpp2::GetGroupReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_getGroup(rpcOptions, p_req); +} + +folly::Future< ::nebula::meta::cpp2::GetGroupResp> MetaServiceAsyncClient::future_getGroup(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetGroupReq& p_req) { + folly::Promise< ::nebula::meta::cpp2::GetGroupResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_getGroup, channel_); + getGroup(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::meta::cpp2::GetGroupResp> MetaServiceAsyncClient::semifuture_getGroup(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetGroupReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_getGroup, channel_); + auto callback = std::move(callbackAndFuture.first); + getGroup(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> MetaServiceAsyncClient::header_future_getGroup(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetGroupReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_getGroup, channel_); + getGroup(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> MetaServiceAsyncClient::header_semifuture_getGroup(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetGroupReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_getGroup, channel_); + auto callback = std::move(callbackAndFuture.first); + getGroup(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void MetaServiceAsyncClient::getGroup(folly::Function callback, const ::nebula::meta::cpp2::GetGroupReq& p_req) { + getGroup(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper MetaServiceAsyncClient::recv_wrapped_getGroup( ::nebula::meta::cpp2::GetGroupResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = MetaService_getGroup_presult; + constexpr auto const fname = "getGroup"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void MetaServiceAsyncClient::recv_getGroup( ::nebula::meta::cpp2::GetGroupResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_getGroup(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void MetaServiceAsyncClient::recv_instance_getGroup( ::nebula::meta::cpp2::GetGroupResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_getGroup(_return, state); +} + +folly::exception_wrapper MetaServiceAsyncClient::recv_instance_wrapped_getGroup( ::nebula::meta::cpp2::GetGroupResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_getGroup(_return, state); +} + +void MetaServiceAsyncClient::listGroups(std::unique_ptr callback, const ::nebula::meta::cpp2::ListGroupsReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + listGroups(rpcOptions, std::move(callback), p_req); +} + +void MetaServiceAsyncClient::listGroups(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::ListGroupsReq& p_req) { + auto ctx = listGroupsCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + listGroupsImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void MetaServiceAsyncClient::listGroupsImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::ListGroupsReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + listGroupsT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + listGroupsT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> MetaServiceAsyncClient::listGroupsCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "MetaService.listGroups"); +} + +void MetaServiceAsyncClient::sync_listGroups( ::nebula::meta::cpp2::ListGroupsResp& _return, const ::nebula::meta::cpp2::ListGroupsReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_listGroups(rpcOptions, _return, p_req); +} + +void MetaServiceAsyncClient::sync_listGroups(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ListGroupsResp& _return, const ::nebula::meta::cpp2::ListGroupsReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = listGroupsCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + listGroupsImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_listGroups(_return, returnState); + }); +} + + +folly::Future< ::nebula::meta::cpp2::ListGroupsResp> MetaServiceAsyncClient::future_listGroups(const ::nebula::meta::cpp2::ListGroupsReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_listGroups(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ListGroupsResp> MetaServiceAsyncClient::semifuture_listGroups(const ::nebula::meta::cpp2::ListGroupsReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_listGroups(rpcOptions, p_req); +} + +folly::Future< ::nebula::meta::cpp2::ListGroupsResp> MetaServiceAsyncClient::future_listGroups(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListGroupsReq& p_req) { + folly::Promise< ::nebula::meta::cpp2::ListGroupsResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_listGroups, channel_); + listGroups(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::meta::cpp2::ListGroupsResp> MetaServiceAsyncClient::semifuture_listGroups(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListGroupsReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_listGroups, channel_); + auto callback = std::move(callbackAndFuture.first); + listGroups(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> MetaServiceAsyncClient::header_future_listGroups(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListGroupsReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_listGroups, channel_); + listGroups(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> MetaServiceAsyncClient::header_semifuture_listGroups(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListGroupsReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_listGroups, channel_); + auto callback = std::move(callbackAndFuture.first); + listGroups(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void MetaServiceAsyncClient::listGroups(folly::Function callback, const ::nebula::meta::cpp2::ListGroupsReq& p_req) { + listGroups(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper MetaServiceAsyncClient::recv_wrapped_listGroups( ::nebula::meta::cpp2::ListGroupsResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = MetaService_listGroups_presult; + constexpr auto const fname = "listGroups"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void MetaServiceAsyncClient::recv_listGroups( ::nebula::meta::cpp2::ListGroupsResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_listGroups(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void MetaServiceAsyncClient::recv_instance_listGroups( ::nebula::meta::cpp2::ListGroupsResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_listGroups(_return, state); +} + +folly::exception_wrapper MetaServiceAsyncClient::recv_instance_wrapped_listGroups( ::nebula::meta::cpp2::ListGroupsResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_listGroups(_return, state); +} + +void MetaServiceAsyncClient::createBackup(std::unique_ptr callback, const ::nebula::meta::cpp2::CreateBackupReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + createBackup(rpcOptions, std::move(callback), p_req); +} + +void MetaServiceAsyncClient::createBackup(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::CreateBackupReq& p_req) { + auto ctx = createBackupCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + createBackupImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void MetaServiceAsyncClient::createBackupImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::CreateBackupReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + createBackupT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + createBackupT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> MetaServiceAsyncClient::createBackupCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "MetaService.createBackup"); +} + +void MetaServiceAsyncClient::sync_createBackup( ::nebula::meta::cpp2::CreateBackupResp& _return, const ::nebula::meta::cpp2::CreateBackupReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_createBackup(rpcOptions, _return, p_req); +} + +void MetaServiceAsyncClient::sync_createBackup(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::CreateBackupResp& _return, const ::nebula::meta::cpp2::CreateBackupReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = createBackupCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + createBackupImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_createBackup(_return, returnState); + }); +} + + +folly::Future< ::nebula::meta::cpp2::CreateBackupResp> MetaServiceAsyncClient::future_createBackup(const ::nebula::meta::cpp2::CreateBackupReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_createBackup(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::meta::cpp2::CreateBackupResp> MetaServiceAsyncClient::semifuture_createBackup(const ::nebula::meta::cpp2::CreateBackupReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_createBackup(rpcOptions, p_req); +} + +folly::Future< ::nebula::meta::cpp2::CreateBackupResp> MetaServiceAsyncClient::future_createBackup(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateBackupReq& p_req) { + folly::Promise< ::nebula::meta::cpp2::CreateBackupResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_createBackup, channel_); + createBackup(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::meta::cpp2::CreateBackupResp> MetaServiceAsyncClient::semifuture_createBackup(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateBackupReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_createBackup, channel_); + auto callback = std::move(callbackAndFuture.first); + createBackup(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> MetaServiceAsyncClient::header_future_createBackup(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateBackupReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_createBackup, channel_); + createBackup(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> MetaServiceAsyncClient::header_semifuture_createBackup(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateBackupReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_createBackup, channel_); + auto callback = std::move(callbackAndFuture.first); + createBackup(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void MetaServiceAsyncClient::createBackup(folly::Function callback, const ::nebula::meta::cpp2::CreateBackupReq& p_req) { + createBackup(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper MetaServiceAsyncClient::recv_wrapped_createBackup( ::nebula::meta::cpp2::CreateBackupResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = MetaService_createBackup_presult; + constexpr auto const fname = "createBackup"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void MetaServiceAsyncClient::recv_createBackup( ::nebula::meta::cpp2::CreateBackupResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_createBackup(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void MetaServiceAsyncClient::recv_instance_createBackup( ::nebula::meta::cpp2::CreateBackupResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_createBackup(_return, state); +} + +folly::exception_wrapper MetaServiceAsyncClient::recv_instance_wrapped_createBackup( ::nebula::meta::cpp2::CreateBackupResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_createBackup(_return, state); +} + +void MetaServiceAsyncClient::restoreMeta(std::unique_ptr callback, const ::nebula::meta::cpp2::RestoreMetaReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + restoreMeta(rpcOptions, std::move(callback), p_req); +} + +void MetaServiceAsyncClient::restoreMeta(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::RestoreMetaReq& p_req) { + auto ctx = restoreMetaCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + restoreMetaImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void MetaServiceAsyncClient::restoreMetaImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::RestoreMetaReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + restoreMetaT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + restoreMetaT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> MetaServiceAsyncClient::restoreMetaCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "MetaService.restoreMeta"); +} + +void MetaServiceAsyncClient::sync_restoreMeta( ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::RestoreMetaReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_restoreMeta(rpcOptions, _return, p_req); +} + +void MetaServiceAsyncClient::sync_restoreMeta(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::RestoreMetaReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = restoreMetaCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + restoreMetaImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_restoreMeta(_return, returnState); + }); +} + + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::future_restoreMeta(const ::nebula::meta::cpp2::RestoreMetaReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_restoreMeta(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::semifuture_restoreMeta(const ::nebula::meta::cpp2::RestoreMetaReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_restoreMeta(rpcOptions, p_req); +} + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::future_restoreMeta(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::RestoreMetaReq& p_req) { + folly::Promise< ::nebula::meta::cpp2::ExecResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_restoreMeta, channel_); + restoreMeta(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::semifuture_restoreMeta(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::RestoreMetaReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_restoreMeta, channel_); + auto callback = std::move(callbackAndFuture.first); + restoreMeta(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> MetaServiceAsyncClient::header_future_restoreMeta(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::RestoreMetaReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_restoreMeta, channel_); + restoreMeta(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> MetaServiceAsyncClient::header_semifuture_restoreMeta(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::RestoreMetaReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_restoreMeta, channel_); + auto callback = std::move(callbackAndFuture.first); + restoreMeta(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void MetaServiceAsyncClient::restoreMeta(folly::Function callback, const ::nebula::meta::cpp2::RestoreMetaReq& p_req) { + restoreMeta(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper MetaServiceAsyncClient::recv_wrapped_restoreMeta( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = MetaService_restoreMeta_presult; + constexpr auto const fname = "restoreMeta"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void MetaServiceAsyncClient::recv_restoreMeta( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_restoreMeta(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void MetaServiceAsyncClient::recv_instance_restoreMeta( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_restoreMeta(_return, state); +} + +folly::exception_wrapper MetaServiceAsyncClient::recv_instance_wrapped_restoreMeta( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_restoreMeta(_return, state); +} + +void MetaServiceAsyncClient::addListener(std::unique_ptr callback, const ::nebula::meta::cpp2::AddListenerReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + addListener(rpcOptions, std::move(callback), p_req); +} + +void MetaServiceAsyncClient::addListener(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::AddListenerReq& p_req) { + auto ctx = addListenerCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + addListenerImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void MetaServiceAsyncClient::addListenerImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::AddListenerReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + addListenerT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + addListenerT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> MetaServiceAsyncClient::addListenerCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "MetaService.addListener"); +} + +void MetaServiceAsyncClient::sync_addListener( ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::AddListenerReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_addListener(rpcOptions, _return, p_req); +} + +void MetaServiceAsyncClient::sync_addListener(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::AddListenerReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = addListenerCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + addListenerImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_addListener(_return, returnState); + }); +} + + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::future_addListener(const ::nebula::meta::cpp2::AddListenerReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_addListener(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::semifuture_addListener(const ::nebula::meta::cpp2::AddListenerReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_addListener(rpcOptions, p_req); +} + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::future_addListener(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::AddListenerReq& p_req) { + folly::Promise< ::nebula::meta::cpp2::ExecResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_addListener, channel_); + addListener(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::semifuture_addListener(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::AddListenerReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_addListener, channel_); + auto callback = std::move(callbackAndFuture.first); + addListener(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> MetaServiceAsyncClient::header_future_addListener(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::AddListenerReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_addListener, channel_); + addListener(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> MetaServiceAsyncClient::header_semifuture_addListener(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::AddListenerReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_addListener, channel_); + auto callback = std::move(callbackAndFuture.first); + addListener(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void MetaServiceAsyncClient::addListener(folly::Function callback, const ::nebula::meta::cpp2::AddListenerReq& p_req) { + addListener(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper MetaServiceAsyncClient::recv_wrapped_addListener( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = MetaService_addListener_presult; + constexpr auto const fname = "addListener"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void MetaServiceAsyncClient::recv_addListener( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_addListener(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void MetaServiceAsyncClient::recv_instance_addListener( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_addListener(_return, state); +} + +folly::exception_wrapper MetaServiceAsyncClient::recv_instance_wrapped_addListener( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_addListener(_return, state); +} + +void MetaServiceAsyncClient::removeListener(std::unique_ptr callback, const ::nebula::meta::cpp2::RemoveListenerReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + removeListener(rpcOptions, std::move(callback), p_req); +} + +void MetaServiceAsyncClient::removeListener(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::RemoveListenerReq& p_req) { + auto ctx = removeListenerCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + removeListenerImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void MetaServiceAsyncClient::removeListenerImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::RemoveListenerReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + removeListenerT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + removeListenerT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> MetaServiceAsyncClient::removeListenerCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "MetaService.removeListener"); +} + +void MetaServiceAsyncClient::sync_removeListener( ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::RemoveListenerReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_removeListener(rpcOptions, _return, p_req); +} + +void MetaServiceAsyncClient::sync_removeListener(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::RemoveListenerReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = removeListenerCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + removeListenerImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_removeListener(_return, returnState); + }); +} + + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::future_removeListener(const ::nebula::meta::cpp2::RemoveListenerReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_removeListener(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::semifuture_removeListener(const ::nebula::meta::cpp2::RemoveListenerReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_removeListener(rpcOptions, p_req); +} + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::future_removeListener(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::RemoveListenerReq& p_req) { + folly::Promise< ::nebula::meta::cpp2::ExecResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_removeListener, channel_); + removeListener(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::semifuture_removeListener(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::RemoveListenerReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_removeListener, channel_); + auto callback = std::move(callbackAndFuture.first); + removeListener(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> MetaServiceAsyncClient::header_future_removeListener(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::RemoveListenerReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_removeListener, channel_); + removeListener(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> MetaServiceAsyncClient::header_semifuture_removeListener(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::RemoveListenerReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_removeListener, channel_); + auto callback = std::move(callbackAndFuture.first); + removeListener(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void MetaServiceAsyncClient::removeListener(folly::Function callback, const ::nebula::meta::cpp2::RemoveListenerReq& p_req) { + removeListener(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper MetaServiceAsyncClient::recv_wrapped_removeListener( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = MetaService_removeListener_presult; + constexpr auto const fname = "removeListener"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void MetaServiceAsyncClient::recv_removeListener( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_removeListener(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void MetaServiceAsyncClient::recv_instance_removeListener( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_removeListener(_return, state); +} + +folly::exception_wrapper MetaServiceAsyncClient::recv_instance_wrapped_removeListener( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_removeListener(_return, state); +} + +void MetaServiceAsyncClient::listListener(std::unique_ptr callback, const ::nebula::meta::cpp2::ListListenerReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + listListener(rpcOptions, std::move(callback), p_req); +} + +void MetaServiceAsyncClient::listListener(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::ListListenerReq& p_req) { + auto ctx = listListenerCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + listListenerImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void MetaServiceAsyncClient::listListenerImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::ListListenerReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + listListenerT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + listListenerT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> MetaServiceAsyncClient::listListenerCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "MetaService.listListener"); +} + +void MetaServiceAsyncClient::sync_listListener( ::nebula::meta::cpp2::ListListenerResp& _return, const ::nebula::meta::cpp2::ListListenerReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_listListener(rpcOptions, _return, p_req); +} + +void MetaServiceAsyncClient::sync_listListener(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ListListenerResp& _return, const ::nebula::meta::cpp2::ListListenerReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = listListenerCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + listListenerImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_listListener(_return, returnState); + }); +} + + +folly::Future< ::nebula::meta::cpp2::ListListenerResp> MetaServiceAsyncClient::future_listListener(const ::nebula::meta::cpp2::ListListenerReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_listListener(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ListListenerResp> MetaServiceAsyncClient::semifuture_listListener(const ::nebula::meta::cpp2::ListListenerReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_listListener(rpcOptions, p_req); +} + +folly::Future< ::nebula::meta::cpp2::ListListenerResp> MetaServiceAsyncClient::future_listListener(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListListenerReq& p_req) { + folly::Promise< ::nebula::meta::cpp2::ListListenerResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_listListener, channel_); + listListener(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::meta::cpp2::ListListenerResp> MetaServiceAsyncClient::semifuture_listListener(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListListenerReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_listListener, channel_); + auto callback = std::move(callbackAndFuture.first); + listListener(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> MetaServiceAsyncClient::header_future_listListener(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListListenerReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_listListener, channel_); + listListener(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> MetaServiceAsyncClient::header_semifuture_listListener(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListListenerReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_listListener, channel_); + auto callback = std::move(callbackAndFuture.first); + listListener(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void MetaServiceAsyncClient::listListener(folly::Function callback, const ::nebula::meta::cpp2::ListListenerReq& p_req) { + listListener(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper MetaServiceAsyncClient::recv_wrapped_listListener( ::nebula::meta::cpp2::ListListenerResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = MetaService_listListener_presult; + constexpr auto const fname = "listListener"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void MetaServiceAsyncClient::recv_listListener( ::nebula::meta::cpp2::ListListenerResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_listListener(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void MetaServiceAsyncClient::recv_instance_listListener( ::nebula::meta::cpp2::ListListenerResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_listListener(_return, state); +} + +folly::exception_wrapper MetaServiceAsyncClient::recv_instance_wrapped_listListener( ::nebula::meta::cpp2::ListListenerResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_listListener(_return, state); +} + +void MetaServiceAsyncClient::getStats(std::unique_ptr callback, const ::nebula::meta::cpp2::GetStatsReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + getStats(rpcOptions, std::move(callback), p_req); +} + +void MetaServiceAsyncClient::getStats(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::GetStatsReq& p_req) { + auto ctx = getStatsCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + getStatsImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void MetaServiceAsyncClient::getStatsImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::GetStatsReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + getStatsT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + getStatsT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> MetaServiceAsyncClient::getStatsCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "MetaService.getStats"); +} + +void MetaServiceAsyncClient::sync_getStats( ::nebula::meta::cpp2::GetStatsResp& _return, const ::nebula::meta::cpp2::GetStatsReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_getStats(rpcOptions, _return, p_req); +} + +void MetaServiceAsyncClient::sync_getStats(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::GetStatsResp& _return, const ::nebula::meta::cpp2::GetStatsReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = getStatsCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + getStatsImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_getStats(_return, returnState); + }); +} + + +folly::Future< ::nebula::meta::cpp2::GetStatsResp> MetaServiceAsyncClient::future_getStats(const ::nebula::meta::cpp2::GetStatsReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_getStats(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::meta::cpp2::GetStatsResp> MetaServiceAsyncClient::semifuture_getStats(const ::nebula::meta::cpp2::GetStatsReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_getStats(rpcOptions, p_req); +} + +folly::Future< ::nebula::meta::cpp2::GetStatsResp> MetaServiceAsyncClient::future_getStats(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetStatsReq& p_req) { + folly::Promise< ::nebula::meta::cpp2::GetStatsResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_getStats, channel_); + getStats(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::meta::cpp2::GetStatsResp> MetaServiceAsyncClient::semifuture_getStats(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetStatsReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_getStats, channel_); + auto callback = std::move(callbackAndFuture.first); + getStats(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> MetaServiceAsyncClient::header_future_getStats(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetStatsReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_getStats, channel_); + getStats(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> MetaServiceAsyncClient::header_semifuture_getStats(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetStatsReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_getStats, channel_); + auto callback = std::move(callbackAndFuture.first); + getStats(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void MetaServiceAsyncClient::getStats(folly::Function callback, const ::nebula::meta::cpp2::GetStatsReq& p_req) { + getStats(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper MetaServiceAsyncClient::recv_wrapped_getStats( ::nebula::meta::cpp2::GetStatsResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = MetaService_getStats_presult; + constexpr auto const fname = "getStats"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void MetaServiceAsyncClient::recv_getStats( ::nebula::meta::cpp2::GetStatsResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_getStats(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void MetaServiceAsyncClient::recv_instance_getStats( ::nebula::meta::cpp2::GetStatsResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_getStats(_return, state); +} + +folly::exception_wrapper MetaServiceAsyncClient::recv_instance_wrapped_getStats( ::nebula::meta::cpp2::GetStatsResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_getStats(_return, state); +} + +void MetaServiceAsyncClient::signInFTService(std::unique_ptr callback, const ::nebula::meta::cpp2::SignInFTServiceReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + signInFTService(rpcOptions, std::move(callback), p_req); +} + +void MetaServiceAsyncClient::signInFTService(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::SignInFTServiceReq& p_req) { + auto ctx = signInFTServiceCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + signInFTServiceImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void MetaServiceAsyncClient::signInFTServiceImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::SignInFTServiceReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + signInFTServiceT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + signInFTServiceT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> MetaServiceAsyncClient::signInFTServiceCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "MetaService.signInFTService"); +} + +void MetaServiceAsyncClient::sync_signInFTService( ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::SignInFTServiceReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_signInFTService(rpcOptions, _return, p_req); +} + +void MetaServiceAsyncClient::sync_signInFTService(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::SignInFTServiceReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = signInFTServiceCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + signInFTServiceImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_signInFTService(_return, returnState); + }); +} + + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::future_signInFTService(const ::nebula::meta::cpp2::SignInFTServiceReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_signInFTService(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::semifuture_signInFTService(const ::nebula::meta::cpp2::SignInFTServiceReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_signInFTService(rpcOptions, p_req); +} + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::future_signInFTService(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::SignInFTServiceReq& p_req) { + folly::Promise< ::nebula::meta::cpp2::ExecResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_signInFTService, channel_); + signInFTService(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::semifuture_signInFTService(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::SignInFTServiceReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_signInFTService, channel_); + auto callback = std::move(callbackAndFuture.first); + signInFTService(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> MetaServiceAsyncClient::header_future_signInFTService(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::SignInFTServiceReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_signInFTService, channel_); + signInFTService(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> MetaServiceAsyncClient::header_semifuture_signInFTService(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::SignInFTServiceReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_signInFTService, channel_); + auto callback = std::move(callbackAndFuture.first); + signInFTService(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void MetaServiceAsyncClient::signInFTService(folly::Function callback, const ::nebula::meta::cpp2::SignInFTServiceReq& p_req) { + signInFTService(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper MetaServiceAsyncClient::recv_wrapped_signInFTService( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = MetaService_signInFTService_presult; + constexpr auto const fname = "signInFTService"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void MetaServiceAsyncClient::recv_signInFTService( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_signInFTService(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void MetaServiceAsyncClient::recv_instance_signInFTService( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_signInFTService(_return, state); +} + +folly::exception_wrapper MetaServiceAsyncClient::recv_instance_wrapped_signInFTService( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_signInFTService(_return, state); +} + +void MetaServiceAsyncClient::signOutFTService(std::unique_ptr callback, const ::nebula::meta::cpp2::SignOutFTServiceReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + signOutFTService(rpcOptions, std::move(callback), p_req); +} + +void MetaServiceAsyncClient::signOutFTService(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::SignOutFTServiceReq& p_req) { + auto ctx = signOutFTServiceCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + signOutFTServiceImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void MetaServiceAsyncClient::signOutFTServiceImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::SignOutFTServiceReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + signOutFTServiceT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + signOutFTServiceT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> MetaServiceAsyncClient::signOutFTServiceCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "MetaService.signOutFTService"); +} + +void MetaServiceAsyncClient::sync_signOutFTService( ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::SignOutFTServiceReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_signOutFTService(rpcOptions, _return, p_req); +} + +void MetaServiceAsyncClient::sync_signOutFTService(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::SignOutFTServiceReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = signOutFTServiceCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + signOutFTServiceImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_signOutFTService(_return, returnState); + }); +} + + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::future_signOutFTService(const ::nebula::meta::cpp2::SignOutFTServiceReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_signOutFTService(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::semifuture_signOutFTService(const ::nebula::meta::cpp2::SignOutFTServiceReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_signOutFTService(rpcOptions, p_req); +} + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::future_signOutFTService(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::SignOutFTServiceReq& p_req) { + folly::Promise< ::nebula::meta::cpp2::ExecResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_signOutFTService, channel_); + signOutFTService(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::semifuture_signOutFTService(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::SignOutFTServiceReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_signOutFTService, channel_); + auto callback = std::move(callbackAndFuture.first); + signOutFTService(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> MetaServiceAsyncClient::header_future_signOutFTService(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::SignOutFTServiceReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_signOutFTService, channel_); + signOutFTService(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> MetaServiceAsyncClient::header_semifuture_signOutFTService(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::SignOutFTServiceReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_signOutFTService, channel_); + auto callback = std::move(callbackAndFuture.first); + signOutFTService(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void MetaServiceAsyncClient::signOutFTService(folly::Function callback, const ::nebula::meta::cpp2::SignOutFTServiceReq& p_req) { + signOutFTService(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper MetaServiceAsyncClient::recv_wrapped_signOutFTService( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = MetaService_signOutFTService_presult; + constexpr auto const fname = "signOutFTService"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void MetaServiceAsyncClient::recv_signOutFTService( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_signOutFTService(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void MetaServiceAsyncClient::recv_instance_signOutFTService( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_signOutFTService(_return, state); +} + +folly::exception_wrapper MetaServiceAsyncClient::recv_instance_wrapped_signOutFTService( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_signOutFTService(_return, state); +} + +void MetaServiceAsyncClient::listFTClients(std::unique_ptr callback, const ::nebula::meta::cpp2::ListFTClientsReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + listFTClients(rpcOptions, std::move(callback), p_req); +} + +void MetaServiceAsyncClient::listFTClients(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::ListFTClientsReq& p_req) { + auto ctx = listFTClientsCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + listFTClientsImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void MetaServiceAsyncClient::listFTClientsImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::ListFTClientsReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + listFTClientsT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + listFTClientsT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> MetaServiceAsyncClient::listFTClientsCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "MetaService.listFTClients"); +} + +void MetaServiceAsyncClient::sync_listFTClients( ::nebula::meta::cpp2::ListFTClientsResp& _return, const ::nebula::meta::cpp2::ListFTClientsReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_listFTClients(rpcOptions, _return, p_req); +} + +void MetaServiceAsyncClient::sync_listFTClients(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ListFTClientsResp& _return, const ::nebula::meta::cpp2::ListFTClientsReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = listFTClientsCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + listFTClientsImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_listFTClients(_return, returnState); + }); +} + + +folly::Future< ::nebula::meta::cpp2::ListFTClientsResp> MetaServiceAsyncClient::future_listFTClients(const ::nebula::meta::cpp2::ListFTClientsReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_listFTClients(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ListFTClientsResp> MetaServiceAsyncClient::semifuture_listFTClients(const ::nebula::meta::cpp2::ListFTClientsReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_listFTClients(rpcOptions, p_req); +} + +folly::Future< ::nebula::meta::cpp2::ListFTClientsResp> MetaServiceAsyncClient::future_listFTClients(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListFTClientsReq& p_req) { + folly::Promise< ::nebula::meta::cpp2::ListFTClientsResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_listFTClients, channel_); + listFTClients(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::meta::cpp2::ListFTClientsResp> MetaServiceAsyncClient::semifuture_listFTClients(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListFTClientsReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_listFTClients, channel_); + auto callback = std::move(callbackAndFuture.first); + listFTClients(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> MetaServiceAsyncClient::header_future_listFTClients(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListFTClientsReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_listFTClients, channel_); + listFTClients(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> MetaServiceAsyncClient::header_semifuture_listFTClients(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListFTClientsReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_listFTClients, channel_); + auto callback = std::move(callbackAndFuture.first); + listFTClients(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void MetaServiceAsyncClient::listFTClients(folly::Function callback, const ::nebula::meta::cpp2::ListFTClientsReq& p_req) { + listFTClients(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper MetaServiceAsyncClient::recv_wrapped_listFTClients( ::nebula::meta::cpp2::ListFTClientsResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = MetaService_listFTClients_presult; + constexpr auto const fname = "listFTClients"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void MetaServiceAsyncClient::recv_listFTClients( ::nebula::meta::cpp2::ListFTClientsResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_listFTClients(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void MetaServiceAsyncClient::recv_instance_listFTClients( ::nebula::meta::cpp2::ListFTClientsResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_listFTClients(_return, state); +} + +folly::exception_wrapper MetaServiceAsyncClient::recv_instance_wrapped_listFTClients( ::nebula::meta::cpp2::ListFTClientsResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_listFTClients(_return, state); +} + +void MetaServiceAsyncClient::createFTIndex(std::unique_ptr callback, const ::nebula::meta::cpp2::CreateFTIndexReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + createFTIndex(rpcOptions, std::move(callback), p_req); +} + +void MetaServiceAsyncClient::createFTIndex(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::CreateFTIndexReq& p_req) { + auto ctx = createFTIndexCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + createFTIndexImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void MetaServiceAsyncClient::createFTIndexImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::CreateFTIndexReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + createFTIndexT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + createFTIndexT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> MetaServiceAsyncClient::createFTIndexCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "MetaService.createFTIndex"); +} + +void MetaServiceAsyncClient::sync_createFTIndex( ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::CreateFTIndexReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_createFTIndex(rpcOptions, _return, p_req); +} + +void MetaServiceAsyncClient::sync_createFTIndex(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::CreateFTIndexReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = createFTIndexCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + createFTIndexImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_createFTIndex(_return, returnState); + }); +} + + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::future_createFTIndex(const ::nebula::meta::cpp2::CreateFTIndexReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_createFTIndex(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::semifuture_createFTIndex(const ::nebula::meta::cpp2::CreateFTIndexReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_createFTIndex(rpcOptions, p_req); +} + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::future_createFTIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateFTIndexReq& p_req) { + folly::Promise< ::nebula::meta::cpp2::ExecResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_createFTIndex, channel_); + createFTIndex(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::semifuture_createFTIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateFTIndexReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_createFTIndex, channel_); + auto callback = std::move(callbackAndFuture.first); + createFTIndex(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> MetaServiceAsyncClient::header_future_createFTIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateFTIndexReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_createFTIndex, channel_); + createFTIndex(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> MetaServiceAsyncClient::header_semifuture_createFTIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateFTIndexReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_createFTIndex, channel_); + auto callback = std::move(callbackAndFuture.first); + createFTIndex(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void MetaServiceAsyncClient::createFTIndex(folly::Function callback, const ::nebula::meta::cpp2::CreateFTIndexReq& p_req) { + createFTIndex(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper MetaServiceAsyncClient::recv_wrapped_createFTIndex( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = MetaService_createFTIndex_presult; + constexpr auto const fname = "createFTIndex"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void MetaServiceAsyncClient::recv_createFTIndex( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_createFTIndex(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void MetaServiceAsyncClient::recv_instance_createFTIndex( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_createFTIndex(_return, state); +} + +folly::exception_wrapper MetaServiceAsyncClient::recv_instance_wrapped_createFTIndex( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_createFTIndex(_return, state); +} + +void MetaServiceAsyncClient::dropFTIndex(std::unique_ptr callback, const ::nebula::meta::cpp2::DropFTIndexReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + dropFTIndex(rpcOptions, std::move(callback), p_req); +} + +void MetaServiceAsyncClient::dropFTIndex(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::DropFTIndexReq& p_req) { + auto ctx = dropFTIndexCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + dropFTIndexImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void MetaServiceAsyncClient::dropFTIndexImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::DropFTIndexReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + dropFTIndexT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + dropFTIndexT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> MetaServiceAsyncClient::dropFTIndexCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "MetaService.dropFTIndex"); +} + +void MetaServiceAsyncClient::sync_dropFTIndex( ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::DropFTIndexReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_dropFTIndex(rpcOptions, _return, p_req); +} + +void MetaServiceAsyncClient::sync_dropFTIndex(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::DropFTIndexReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = dropFTIndexCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + dropFTIndexImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_dropFTIndex(_return, returnState); + }); +} + + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::future_dropFTIndex(const ::nebula::meta::cpp2::DropFTIndexReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_dropFTIndex(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::semifuture_dropFTIndex(const ::nebula::meta::cpp2::DropFTIndexReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_dropFTIndex(rpcOptions, p_req); +} + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::future_dropFTIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropFTIndexReq& p_req) { + folly::Promise< ::nebula::meta::cpp2::ExecResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_dropFTIndex, channel_); + dropFTIndex(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::semifuture_dropFTIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropFTIndexReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_dropFTIndex, channel_); + auto callback = std::move(callbackAndFuture.first); + dropFTIndex(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> MetaServiceAsyncClient::header_future_dropFTIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropFTIndexReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_dropFTIndex, channel_); + dropFTIndex(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> MetaServiceAsyncClient::header_semifuture_dropFTIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropFTIndexReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_dropFTIndex, channel_); + auto callback = std::move(callbackAndFuture.first); + dropFTIndex(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void MetaServiceAsyncClient::dropFTIndex(folly::Function callback, const ::nebula::meta::cpp2::DropFTIndexReq& p_req) { + dropFTIndex(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper MetaServiceAsyncClient::recv_wrapped_dropFTIndex( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = MetaService_dropFTIndex_presult; + constexpr auto const fname = "dropFTIndex"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void MetaServiceAsyncClient::recv_dropFTIndex( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_dropFTIndex(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void MetaServiceAsyncClient::recv_instance_dropFTIndex( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_dropFTIndex(_return, state); +} + +folly::exception_wrapper MetaServiceAsyncClient::recv_instance_wrapped_dropFTIndex( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_dropFTIndex(_return, state); +} + +void MetaServiceAsyncClient::listFTIndexes(std::unique_ptr callback, const ::nebula::meta::cpp2::ListFTIndexesReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + listFTIndexes(rpcOptions, std::move(callback), p_req); +} + +void MetaServiceAsyncClient::listFTIndexes(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::ListFTIndexesReq& p_req) { + auto ctx = listFTIndexesCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + listFTIndexesImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void MetaServiceAsyncClient::listFTIndexesImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::ListFTIndexesReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + listFTIndexesT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + listFTIndexesT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> MetaServiceAsyncClient::listFTIndexesCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "MetaService.listFTIndexes"); +} + +void MetaServiceAsyncClient::sync_listFTIndexes( ::nebula::meta::cpp2::ListFTIndexesResp& _return, const ::nebula::meta::cpp2::ListFTIndexesReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_listFTIndexes(rpcOptions, _return, p_req); +} + +void MetaServiceAsyncClient::sync_listFTIndexes(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ListFTIndexesResp& _return, const ::nebula::meta::cpp2::ListFTIndexesReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = listFTIndexesCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + listFTIndexesImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_listFTIndexes(_return, returnState); + }); +} + + +folly::Future< ::nebula::meta::cpp2::ListFTIndexesResp> MetaServiceAsyncClient::future_listFTIndexes(const ::nebula::meta::cpp2::ListFTIndexesReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_listFTIndexes(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ListFTIndexesResp> MetaServiceAsyncClient::semifuture_listFTIndexes(const ::nebula::meta::cpp2::ListFTIndexesReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_listFTIndexes(rpcOptions, p_req); +} + +folly::Future< ::nebula::meta::cpp2::ListFTIndexesResp> MetaServiceAsyncClient::future_listFTIndexes(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListFTIndexesReq& p_req) { + folly::Promise< ::nebula::meta::cpp2::ListFTIndexesResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_listFTIndexes, channel_); + listFTIndexes(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::meta::cpp2::ListFTIndexesResp> MetaServiceAsyncClient::semifuture_listFTIndexes(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListFTIndexesReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_listFTIndexes, channel_); + auto callback = std::move(callbackAndFuture.first); + listFTIndexes(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> MetaServiceAsyncClient::header_future_listFTIndexes(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListFTIndexesReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_listFTIndexes, channel_); + listFTIndexes(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> MetaServiceAsyncClient::header_semifuture_listFTIndexes(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListFTIndexesReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_listFTIndexes, channel_); + auto callback = std::move(callbackAndFuture.first); + listFTIndexes(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void MetaServiceAsyncClient::listFTIndexes(folly::Function callback, const ::nebula::meta::cpp2::ListFTIndexesReq& p_req) { + listFTIndexes(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper MetaServiceAsyncClient::recv_wrapped_listFTIndexes( ::nebula::meta::cpp2::ListFTIndexesResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = MetaService_listFTIndexes_presult; + constexpr auto const fname = "listFTIndexes"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void MetaServiceAsyncClient::recv_listFTIndexes( ::nebula::meta::cpp2::ListFTIndexesResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_listFTIndexes(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void MetaServiceAsyncClient::recv_instance_listFTIndexes( ::nebula::meta::cpp2::ListFTIndexesResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_listFTIndexes(_return, state); +} + +folly::exception_wrapper MetaServiceAsyncClient::recv_instance_wrapped_listFTIndexes( ::nebula::meta::cpp2::ListFTIndexesResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_listFTIndexes(_return, state); +} + +void MetaServiceAsyncClient::createSession(std::unique_ptr callback, const ::nebula::meta::cpp2::CreateSessionReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + createSession(rpcOptions, std::move(callback), p_req); +} + +void MetaServiceAsyncClient::createSession(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::CreateSessionReq& p_req) { + auto ctx = createSessionCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + createSessionImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void MetaServiceAsyncClient::createSessionImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::CreateSessionReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + createSessionT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + createSessionT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> MetaServiceAsyncClient::createSessionCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "MetaService.createSession"); +} + +void MetaServiceAsyncClient::sync_createSession( ::nebula::meta::cpp2::CreateSessionResp& _return, const ::nebula::meta::cpp2::CreateSessionReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_createSession(rpcOptions, _return, p_req); +} + +void MetaServiceAsyncClient::sync_createSession(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::CreateSessionResp& _return, const ::nebula::meta::cpp2::CreateSessionReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = createSessionCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + createSessionImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_createSession(_return, returnState); + }); +} + + +folly::Future< ::nebula::meta::cpp2::CreateSessionResp> MetaServiceAsyncClient::future_createSession(const ::nebula::meta::cpp2::CreateSessionReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_createSession(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::meta::cpp2::CreateSessionResp> MetaServiceAsyncClient::semifuture_createSession(const ::nebula::meta::cpp2::CreateSessionReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_createSession(rpcOptions, p_req); +} + +folly::Future< ::nebula::meta::cpp2::CreateSessionResp> MetaServiceAsyncClient::future_createSession(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateSessionReq& p_req) { + folly::Promise< ::nebula::meta::cpp2::CreateSessionResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_createSession, channel_); + createSession(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::meta::cpp2::CreateSessionResp> MetaServiceAsyncClient::semifuture_createSession(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateSessionReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_createSession, channel_); + auto callback = std::move(callbackAndFuture.first); + createSession(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> MetaServiceAsyncClient::header_future_createSession(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateSessionReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_createSession, channel_); + createSession(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> MetaServiceAsyncClient::header_semifuture_createSession(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateSessionReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_createSession, channel_); + auto callback = std::move(callbackAndFuture.first); + createSession(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void MetaServiceAsyncClient::createSession(folly::Function callback, const ::nebula::meta::cpp2::CreateSessionReq& p_req) { + createSession(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper MetaServiceAsyncClient::recv_wrapped_createSession( ::nebula::meta::cpp2::CreateSessionResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = MetaService_createSession_presult; + constexpr auto const fname = "createSession"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void MetaServiceAsyncClient::recv_createSession( ::nebula::meta::cpp2::CreateSessionResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_createSession(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void MetaServiceAsyncClient::recv_instance_createSession( ::nebula::meta::cpp2::CreateSessionResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_createSession(_return, state); +} + +folly::exception_wrapper MetaServiceAsyncClient::recv_instance_wrapped_createSession( ::nebula::meta::cpp2::CreateSessionResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_createSession(_return, state); +} + +void MetaServiceAsyncClient::updateSessions(std::unique_ptr callback, const ::nebula::meta::cpp2::UpdateSessionsReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + updateSessions(rpcOptions, std::move(callback), p_req); +} + +void MetaServiceAsyncClient::updateSessions(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::UpdateSessionsReq& p_req) { + auto ctx = updateSessionsCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + updateSessionsImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void MetaServiceAsyncClient::updateSessionsImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::UpdateSessionsReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + updateSessionsT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + updateSessionsT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> MetaServiceAsyncClient::updateSessionsCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "MetaService.updateSessions"); +} + +void MetaServiceAsyncClient::sync_updateSessions( ::nebula::meta::cpp2::UpdateSessionsResp& _return, const ::nebula::meta::cpp2::UpdateSessionsReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_updateSessions(rpcOptions, _return, p_req); +} + +void MetaServiceAsyncClient::sync_updateSessions(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::UpdateSessionsResp& _return, const ::nebula::meta::cpp2::UpdateSessionsReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = updateSessionsCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + updateSessionsImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_updateSessions(_return, returnState); + }); +} + + +folly::Future< ::nebula::meta::cpp2::UpdateSessionsResp> MetaServiceAsyncClient::future_updateSessions(const ::nebula::meta::cpp2::UpdateSessionsReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_updateSessions(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::meta::cpp2::UpdateSessionsResp> MetaServiceAsyncClient::semifuture_updateSessions(const ::nebula::meta::cpp2::UpdateSessionsReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_updateSessions(rpcOptions, p_req); +} + +folly::Future< ::nebula::meta::cpp2::UpdateSessionsResp> MetaServiceAsyncClient::future_updateSessions(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::UpdateSessionsReq& p_req) { + folly::Promise< ::nebula::meta::cpp2::UpdateSessionsResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_updateSessions, channel_); + updateSessions(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::meta::cpp2::UpdateSessionsResp> MetaServiceAsyncClient::semifuture_updateSessions(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::UpdateSessionsReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_updateSessions, channel_); + auto callback = std::move(callbackAndFuture.first); + updateSessions(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> MetaServiceAsyncClient::header_future_updateSessions(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::UpdateSessionsReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_updateSessions, channel_); + updateSessions(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> MetaServiceAsyncClient::header_semifuture_updateSessions(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::UpdateSessionsReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_updateSessions, channel_); + auto callback = std::move(callbackAndFuture.first); + updateSessions(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void MetaServiceAsyncClient::updateSessions(folly::Function callback, const ::nebula::meta::cpp2::UpdateSessionsReq& p_req) { + updateSessions(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper MetaServiceAsyncClient::recv_wrapped_updateSessions( ::nebula::meta::cpp2::UpdateSessionsResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = MetaService_updateSessions_presult; + constexpr auto const fname = "updateSessions"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void MetaServiceAsyncClient::recv_updateSessions( ::nebula::meta::cpp2::UpdateSessionsResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_updateSessions(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void MetaServiceAsyncClient::recv_instance_updateSessions( ::nebula::meta::cpp2::UpdateSessionsResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_updateSessions(_return, state); +} + +folly::exception_wrapper MetaServiceAsyncClient::recv_instance_wrapped_updateSessions( ::nebula::meta::cpp2::UpdateSessionsResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_updateSessions(_return, state); +} + +void MetaServiceAsyncClient::listSessions(std::unique_ptr callback, const ::nebula::meta::cpp2::ListSessionsReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + listSessions(rpcOptions, std::move(callback), p_req); +} + +void MetaServiceAsyncClient::listSessions(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::ListSessionsReq& p_req) { + auto ctx = listSessionsCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + listSessionsImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void MetaServiceAsyncClient::listSessionsImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::ListSessionsReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + listSessionsT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + listSessionsT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> MetaServiceAsyncClient::listSessionsCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "MetaService.listSessions"); +} + +void MetaServiceAsyncClient::sync_listSessions( ::nebula::meta::cpp2::ListSessionsResp& _return, const ::nebula::meta::cpp2::ListSessionsReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_listSessions(rpcOptions, _return, p_req); +} + +void MetaServiceAsyncClient::sync_listSessions(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ListSessionsResp& _return, const ::nebula::meta::cpp2::ListSessionsReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = listSessionsCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + listSessionsImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_listSessions(_return, returnState); + }); +} + + +folly::Future< ::nebula::meta::cpp2::ListSessionsResp> MetaServiceAsyncClient::future_listSessions(const ::nebula::meta::cpp2::ListSessionsReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_listSessions(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ListSessionsResp> MetaServiceAsyncClient::semifuture_listSessions(const ::nebula::meta::cpp2::ListSessionsReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_listSessions(rpcOptions, p_req); +} + +folly::Future< ::nebula::meta::cpp2::ListSessionsResp> MetaServiceAsyncClient::future_listSessions(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListSessionsReq& p_req) { + folly::Promise< ::nebula::meta::cpp2::ListSessionsResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_listSessions, channel_); + listSessions(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::meta::cpp2::ListSessionsResp> MetaServiceAsyncClient::semifuture_listSessions(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListSessionsReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_listSessions, channel_); + auto callback = std::move(callbackAndFuture.first); + listSessions(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> MetaServiceAsyncClient::header_future_listSessions(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListSessionsReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_listSessions, channel_); + listSessions(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> MetaServiceAsyncClient::header_semifuture_listSessions(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListSessionsReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_listSessions, channel_); + auto callback = std::move(callbackAndFuture.first); + listSessions(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void MetaServiceAsyncClient::listSessions(folly::Function callback, const ::nebula::meta::cpp2::ListSessionsReq& p_req) { + listSessions(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper MetaServiceAsyncClient::recv_wrapped_listSessions( ::nebula::meta::cpp2::ListSessionsResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = MetaService_listSessions_presult; + constexpr auto const fname = "listSessions"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void MetaServiceAsyncClient::recv_listSessions( ::nebula::meta::cpp2::ListSessionsResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_listSessions(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void MetaServiceAsyncClient::recv_instance_listSessions( ::nebula::meta::cpp2::ListSessionsResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_listSessions(_return, state); +} + +folly::exception_wrapper MetaServiceAsyncClient::recv_instance_wrapped_listSessions( ::nebula::meta::cpp2::ListSessionsResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_listSessions(_return, state); +} + +void MetaServiceAsyncClient::getSession(std::unique_ptr callback, const ::nebula::meta::cpp2::GetSessionReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + getSession(rpcOptions, std::move(callback), p_req); +} + +void MetaServiceAsyncClient::getSession(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::GetSessionReq& p_req) { + auto ctx = getSessionCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + getSessionImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void MetaServiceAsyncClient::getSessionImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::GetSessionReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + getSessionT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + getSessionT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> MetaServiceAsyncClient::getSessionCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "MetaService.getSession"); +} + +void MetaServiceAsyncClient::sync_getSession( ::nebula::meta::cpp2::GetSessionResp& _return, const ::nebula::meta::cpp2::GetSessionReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_getSession(rpcOptions, _return, p_req); +} + +void MetaServiceAsyncClient::sync_getSession(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::GetSessionResp& _return, const ::nebula::meta::cpp2::GetSessionReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = getSessionCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + getSessionImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_getSession(_return, returnState); + }); +} + + +folly::Future< ::nebula::meta::cpp2::GetSessionResp> MetaServiceAsyncClient::future_getSession(const ::nebula::meta::cpp2::GetSessionReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_getSession(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::meta::cpp2::GetSessionResp> MetaServiceAsyncClient::semifuture_getSession(const ::nebula::meta::cpp2::GetSessionReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_getSession(rpcOptions, p_req); +} + +folly::Future< ::nebula::meta::cpp2::GetSessionResp> MetaServiceAsyncClient::future_getSession(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetSessionReq& p_req) { + folly::Promise< ::nebula::meta::cpp2::GetSessionResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_getSession, channel_); + getSession(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::meta::cpp2::GetSessionResp> MetaServiceAsyncClient::semifuture_getSession(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetSessionReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_getSession, channel_); + auto callback = std::move(callbackAndFuture.first); + getSession(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> MetaServiceAsyncClient::header_future_getSession(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetSessionReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_getSession, channel_); + getSession(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> MetaServiceAsyncClient::header_semifuture_getSession(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetSessionReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_getSession, channel_); + auto callback = std::move(callbackAndFuture.first); + getSession(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void MetaServiceAsyncClient::getSession(folly::Function callback, const ::nebula::meta::cpp2::GetSessionReq& p_req) { + getSession(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper MetaServiceAsyncClient::recv_wrapped_getSession( ::nebula::meta::cpp2::GetSessionResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = MetaService_getSession_presult; + constexpr auto const fname = "getSession"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void MetaServiceAsyncClient::recv_getSession( ::nebula::meta::cpp2::GetSessionResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_getSession(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void MetaServiceAsyncClient::recv_instance_getSession( ::nebula::meta::cpp2::GetSessionResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_getSession(_return, state); +} + +folly::exception_wrapper MetaServiceAsyncClient::recv_instance_wrapped_getSession( ::nebula::meta::cpp2::GetSessionResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_getSession(_return, state); +} + +void MetaServiceAsyncClient::removeSession(std::unique_ptr callback, const ::nebula::meta::cpp2::RemoveSessionReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + removeSession(rpcOptions, std::move(callback), p_req); +} + +void MetaServiceAsyncClient::removeSession(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::RemoveSessionReq& p_req) { + auto ctx = removeSessionCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + removeSessionImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void MetaServiceAsyncClient::removeSessionImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::RemoveSessionReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + removeSessionT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + removeSessionT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> MetaServiceAsyncClient::removeSessionCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "MetaService.removeSession"); +} + +void MetaServiceAsyncClient::sync_removeSession( ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::RemoveSessionReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_removeSession(rpcOptions, _return, p_req); +} + +void MetaServiceAsyncClient::sync_removeSession(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::RemoveSessionReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = removeSessionCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + removeSessionImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_removeSession(_return, returnState); + }); +} + + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::future_removeSession(const ::nebula::meta::cpp2::RemoveSessionReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_removeSession(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::semifuture_removeSession(const ::nebula::meta::cpp2::RemoveSessionReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_removeSession(rpcOptions, p_req); +} + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::future_removeSession(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::RemoveSessionReq& p_req) { + folly::Promise< ::nebula::meta::cpp2::ExecResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_removeSession, channel_); + removeSession(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::semifuture_removeSession(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::RemoveSessionReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_removeSession, channel_); + auto callback = std::move(callbackAndFuture.first); + removeSession(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> MetaServiceAsyncClient::header_future_removeSession(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::RemoveSessionReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_removeSession, channel_); + removeSession(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> MetaServiceAsyncClient::header_semifuture_removeSession(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::RemoveSessionReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_removeSession, channel_); + auto callback = std::move(callbackAndFuture.first); + removeSession(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void MetaServiceAsyncClient::removeSession(folly::Function callback, const ::nebula::meta::cpp2::RemoveSessionReq& p_req) { + removeSession(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper MetaServiceAsyncClient::recv_wrapped_removeSession( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = MetaService_removeSession_presult; + constexpr auto const fname = "removeSession"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void MetaServiceAsyncClient::recv_removeSession( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_removeSession(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void MetaServiceAsyncClient::recv_instance_removeSession( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_removeSession(_return, state); +} + +folly::exception_wrapper MetaServiceAsyncClient::recv_instance_wrapped_removeSession( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_removeSession(_return, state); +} + +void MetaServiceAsyncClient::killQuery(std::unique_ptr callback, const ::nebula::meta::cpp2::KillQueryReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + killQuery(rpcOptions, std::move(callback), p_req); +} + +void MetaServiceAsyncClient::killQuery(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::KillQueryReq& p_req) { + auto ctx = killQueryCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + killQueryImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void MetaServiceAsyncClient::killQueryImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::KillQueryReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + killQueryT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + killQueryT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> MetaServiceAsyncClient::killQueryCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "MetaService.killQuery"); +} + +void MetaServiceAsyncClient::sync_killQuery( ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::KillQueryReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_killQuery(rpcOptions, _return, p_req); +} + +void MetaServiceAsyncClient::sync_killQuery(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::KillQueryReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = killQueryCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + killQueryImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_killQuery(_return, returnState); + }); +} + + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::future_killQuery(const ::nebula::meta::cpp2::KillQueryReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_killQuery(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::semifuture_killQuery(const ::nebula::meta::cpp2::KillQueryReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_killQuery(rpcOptions, p_req); +} + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::future_killQuery(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::KillQueryReq& p_req) { + folly::Promise< ::nebula::meta::cpp2::ExecResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_killQuery, channel_); + killQuery(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::semifuture_killQuery(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::KillQueryReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_killQuery, channel_); + auto callback = std::move(callbackAndFuture.first); + killQuery(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> MetaServiceAsyncClient::header_future_killQuery(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::KillQueryReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_killQuery, channel_); + killQuery(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> MetaServiceAsyncClient::header_semifuture_killQuery(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::KillQueryReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_killQuery, channel_); + auto callback = std::move(callbackAndFuture.first); + killQuery(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void MetaServiceAsyncClient::killQuery(folly::Function callback, const ::nebula::meta::cpp2::KillQueryReq& p_req) { + killQuery(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper MetaServiceAsyncClient::recv_wrapped_killQuery( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = MetaService_killQuery_presult; + constexpr auto const fname = "killQuery"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void MetaServiceAsyncClient::recv_killQuery( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_killQuery(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void MetaServiceAsyncClient::recv_instance_killQuery( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_killQuery(_return, state); +} + +folly::exception_wrapper MetaServiceAsyncClient::recv_instance_wrapped_killQuery( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_killQuery(_return, state); +} + +void MetaServiceAsyncClient::reportTaskFinish(std::unique_ptr callback, const ::nebula::meta::cpp2::ReportTaskReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + reportTaskFinish(rpcOptions, std::move(callback), p_req); +} + +void MetaServiceAsyncClient::reportTaskFinish(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::ReportTaskReq& p_req) { + auto ctx = reportTaskFinishCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + reportTaskFinishImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void MetaServiceAsyncClient::reportTaskFinishImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::ReportTaskReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + reportTaskFinishT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + reportTaskFinishT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> MetaServiceAsyncClient::reportTaskFinishCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "MetaService.reportTaskFinish"); +} + +void MetaServiceAsyncClient::sync_reportTaskFinish( ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::ReportTaskReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_reportTaskFinish(rpcOptions, _return, p_req); +} + +void MetaServiceAsyncClient::sync_reportTaskFinish(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::ReportTaskReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = reportTaskFinishCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + reportTaskFinishImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_reportTaskFinish(_return, returnState); + }); +} + + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::future_reportTaskFinish(const ::nebula::meta::cpp2::ReportTaskReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_reportTaskFinish(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::semifuture_reportTaskFinish(const ::nebula::meta::cpp2::ReportTaskReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_reportTaskFinish(rpcOptions, p_req); +} + +folly::Future< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::future_reportTaskFinish(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ReportTaskReq& p_req) { + folly::Promise< ::nebula::meta::cpp2::ExecResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_reportTaskFinish, channel_); + reportTaskFinish(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> MetaServiceAsyncClient::semifuture_reportTaskFinish(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ReportTaskReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_reportTaskFinish, channel_); + auto callback = std::move(callbackAndFuture.first); + reportTaskFinish(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> MetaServiceAsyncClient::header_future_reportTaskFinish(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ReportTaskReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_reportTaskFinish, channel_); + reportTaskFinish(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> MetaServiceAsyncClient::header_semifuture_reportTaskFinish(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ReportTaskReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_reportTaskFinish, channel_); + auto callback = std::move(callbackAndFuture.first); + reportTaskFinish(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void MetaServiceAsyncClient::reportTaskFinish(folly::Function callback, const ::nebula::meta::cpp2::ReportTaskReq& p_req) { + reportTaskFinish(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper MetaServiceAsyncClient::recv_wrapped_reportTaskFinish( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = MetaService_reportTaskFinish_presult; + constexpr auto const fname = "reportTaskFinish"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void MetaServiceAsyncClient::recv_reportTaskFinish( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_reportTaskFinish(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void MetaServiceAsyncClient::recv_instance_reportTaskFinish( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_reportTaskFinish(_return, state); +} + +folly::exception_wrapper MetaServiceAsyncClient::recv_instance_wrapped_reportTaskFinish( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_reportTaskFinish(_return, state); +} + +void MetaServiceAsyncClient::listCluster(std::unique_ptr callback, const ::nebula::meta::cpp2::ListClusterInfoReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + listCluster(rpcOptions, std::move(callback), p_req); +} + +void MetaServiceAsyncClient::listCluster(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::ListClusterInfoReq& p_req) { + auto ctx = listClusterCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + listClusterImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void MetaServiceAsyncClient::listClusterImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::ListClusterInfoReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + listClusterT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + listClusterT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> MetaServiceAsyncClient::listClusterCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "MetaService.listCluster"); +} + +void MetaServiceAsyncClient::sync_listCluster( ::nebula::meta::cpp2::ListClusterInfoResp& _return, const ::nebula::meta::cpp2::ListClusterInfoReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_listCluster(rpcOptions, _return, p_req); +} + +void MetaServiceAsyncClient::sync_listCluster(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ListClusterInfoResp& _return, const ::nebula::meta::cpp2::ListClusterInfoReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = listClusterCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + listClusterImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_listCluster(_return, returnState); + }); +} + + +folly::Future< ::nebula::meta::cpp2::ListClusterInfoResp> MetaServiceAsyncClient::future_listCluster(const ::nebula::meta::cpp2::ListClusterInfoReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_listCluster(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::meta::cpp2::ListClusterInfoResp> MetaServiceAsyncClient::semifuture_listCluster(const ::nebula::meta::cpp2::ListClusterInfoReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_listCluster(rpcOptions, p_req); +} + +folly::Future< ::nebula::meta::cpp2::ListClusterInfoResp> MetaServiceAsyncClient::future_listCluster(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListClusterInfoReq& p_req) { + folly::Promise< ::nebula::meta::cpp2::ListClusterInfoResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_listCluster, channel_); + listCluster(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::meta::cpp2::ListClusterInfoResp> MetaServiceAsyncClient::semifuture_listCluster(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListClusterInfoReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_listCluster, channel_); + auto callback = std::move(callbackAndFuture.first); + listCluster(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> MetaServiceAsyncClient::header_future_listCluster(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListClusterInfoReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_listCluster, channel_); + listCluster(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> MetaServiceAsyncClient::header_semifuture_listCluster(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListClusterInfoReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_listCluster, channel_); + auto callback = std::move(callbackAndFuture.first); + listCluster(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void MetaServiceAsyncClient::listCluster(folly::Function callback, const ::nebula::meta::cpp2::ListClusterInfoReq& p_req) { + listCluster(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper MetaServiceAsyncClient::recv_wrapped_listCluster( ::nebula::meta::cpp2::ListClusterInfoResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = MetaService_listCluster_presult; + constexpr auto const fname = "listCluster"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void MetaServiceAsyncClient::recv_listCluster( ::nebula::meta::cpp2::ListClusterInfoResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_listCluster(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void MetaServiceAsyncClient::recv_instance_listCluster( ::nebula::meta::cpp2::ListClusterInfoResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_listCluster(_return, state); +} + +folly::exception_wrapper MetaServiceAsyncClient::recv_instance_wrapped_listCluster( ::nebula::meta::cpp2::ListClusterInfoResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_listCluster(_return, state); +} + +void MetaServiceAsyncClient::getMetaDirInfo(std::unique_ptr callback, const ::nebula::meta::cpp2::GetMetaDirInfoReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + getMetaDirInfo(rpcOptions, std::move(callback), p_req); +} + +void MetaServiceAsyncClient::getMetaDirInfo(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::GetMetaDirInfoReq& p_req) { + auto ctx = getMetaDirInfoCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + getMetaDirInfoImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void MetaServiceAsyncClient::getMetaDirInfoImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::GetMetaDirInfoReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + getMetaDirInfoT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + getMetaDirInfoT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> MetaServiceAsyncClient::getMetaDirInfoCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "MetaService.getMetaDirInfo"); +} + +void MetaServiceAsyncClient::sync_getMetaDirInfo( ::nebula::meta::cpp2::GetMetaDirInfoResp& _return, const ::nebula::meta::cpp2::GetMetaDirInfoReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_getMetaDirInfo(rpcOptions, _return, p_req); +} + +void MetaServiceAsyncClient::sync_getMetaDirInfo(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::GetMetaDirInfoResp& _return, const ::nebula::meta::cpp2::GetMetaDirInfoReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = getMetaDirInfoCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + getMetaDirInfoImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_getMetaDirInfo(_return, returnState); + }); +} + + +folly::Future< ::nebula::meta::cpp2::GetMetaDirInfoResp> MetaServiceAsyncClient::future_getMetaDirInfo(const ::nebula::meta::cpp2::GetMetaDirInfoReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_getMetaDirInfo(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::meta::cpp2::GetMetaDirInfoResp> MetaServiceAsyncClient::semifuture_getMetaDirInfo(const ::nebula::meta::cpp2::GetMetaDirInfoReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_getMetaDirInfo(rpcOptions, p_req); +} + +folly::Future< ::nebula::meta::cpp2::GetMetaDirInfoResp> MetaServiceAsyncClient::future_getMetaDirInfo(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetMetaDirInfoReq& p_req) { + folly::Promise< ::nebula::meta::cpp2::GetMetaDirInfoResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_getMetaDirInfo, channel_); + getMetaDirInfo(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::meta::cpp2::GetMetaDirInfoResp> MetaServiceAsyncClient::semifuture_getMetaDirInfo(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetMetaDirInfoReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_getMetaDirInfo, channel_); + auto callback = std::move(callbackAndFuture.first); + getMetaDirInfo(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> MetaServiceAsyncClient::header_future_getMetaDirInfo(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetMetaDirInfoReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_getMetaDirInfo, channel_); + getMetaDirInfo(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> MetaServiceAsyncClient::header_semifuture_getMetaDirInfo(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetMetaDirInfoReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_getMetaDirInfo, channel_); + auto callback = std::move(callbackAndFuture.first); + getMetaDirInfo(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void MetaServiceAsyncClient::getMetaDirInfo(folly::Function callback, const ::nebula::meta::cpp2::GetMetaDirInfoReq& p_req) { + getMetaDirInfo(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper MetaServiceAsyncClient::recv_wrapped_getMetaDirInfo( ::nebula::meta::cpp2::GetMetaDirInfoResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = MetaService_getMetaDirInfo_presult; + constexpr auto const fname = "getMetaDirInfo"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void MetaServiceAsyncClient::recv_getMetaDirInfo( ::nebula::meta::cpp2::GetMetaDirInfoResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_getMetaDirInfo(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void MetaServiceAsyncClient::recv_instance_getMetaDirInfo( ::nebula::meta::cpp2::GetMetaDirInfoResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_getMetaDirInfo(_return, state); +} + +folly::exception_wrapper MetaServiceAsyncClient::recv_instance_wrapped_getMetaDirInfo( ::nebula::meta::cpp2::GetMetaDirInfoResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_getMetaDirInfo(_return, state); +} + +void MetaServiceAsyncClient::verifyClientVersion(std::unique_ptr callback, const ::nebula::meta::cpp2::VerifyClientVersionReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + verifyClientVersion(rpcOptions, std::move(callback), p_req); +} + +void MetaServiceAsyncClient::verifyClientVersion(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::VerifyClientVersionReq& p_req) { + auto ctx = verifyClientVersionCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + verifyClientVersionImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void MetaServiceAsyncClient::verifyClientVersionImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::VerifyClientVersionReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + verifyClientVersionT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + verifyClientVersionT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> MetaServiceAsyncClient::verifyClientVersionCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "MetaService.verifyClientVersion"); +} + +void MetaServiceAsyncClient::sync_verifyClientVersion( ::nebula::meta::cpp2::VerifyClientVersionResp& _return, const ::nebula::meta::cpp2::VerifyClientVersionReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_verifyClientVersion(rpcOptions, _return, p_req); +} + +void MetaServiceAsyncClient::sync_verifyClientVersion(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::VerifyClientVersionResp& _return, const ::nebula::meta::cpp2::VerifyClientVersionReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = verifyClientVersionCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + verifyClientVersionImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_verifyClientVersion(_return, returnState); + }); +} + + +folly::Future< ::nebula::meta::cpp2::VerifyClientVersionResp> MetaServiceAsyncClient::future_verifyClientVersion(const ::nebula::meta::cpp2::VerifyClientVersionReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_verifyClientVersion(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::meta::cpp2::VerifyClientVersionResp> MetaServiceAsyncClient::semifuture_verifyClientVersion(const ::nebula::meta::cpp2::VerifyClientVersionReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_verifyClientVersion(rpcOptions, p_req); +} + +folly::Future< ::nebula::meta::cpp2::VerifyClientVersionResp> MetaServiceAsyncClient::future_verifyClientVersion(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::VerifyClientVersionReq& p_req) { + folly::Promise< ::nebula::meta::cpp2::VerifyClientVersionResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_verifyClientVersion, channel_); + verifyClientVersion(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::meta::cpp2::VerifyClientVersionResp> MetaServiceAsyncClient::semifuture_verifyClientVersion(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::VerifyClientVersionReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_verifyClientVersion, channel_); + auto callback = std::move(callbackAndFuture.first); + verifyClientVersion(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> MetaServiceAsyncClient::header_future_verifyClientVersion(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::VerifyClientVersionReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_verifyClientVersion, channel_); + verifyClientVersion(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> MetaServiceAsyncClient::header_semifuture_verifyClientVersion(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::VerifyClientVersionReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_verifyClientVersion, channel_); + auto callback = std::move(callbackAndFuture.first); + verifyClientVersion(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void MetaServiceAsyncClient::verifyClientVersion(folly::Function callback, const ::nebula::meta::cpp2::VerifyClientVersionReq& p_req) { + verifyClientVersion(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper MetaServiceAsyncClient::recv_wrapped_verifyClientVersion( ::nebula::meta::cpp2::VerifyClientVersionResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = MetaService_verifyClientVersion_presult; + constexpr auto const fname = "verifyClientVersion"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void MetaServiceAsyncClient::recv_verifyClientVersion( ::nebula::meta::cpp2::VerifyClientVersionResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_verifyClientVersion(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void MetaServiceAsyncClient::recv_instance_verifyClientVersion( ::nebula::meta::cpp2::VerifyClientVersionResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_verifyClientVersion(_return, state); +} + +folly::exception_wrapper MetaServiceAsyncClient::recv_instance_wrapped_verifyClientVersion( ::nebula::meta::cpp2::VerifyClientVersionResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_verifyClientVersion(_return, state); +} + + +}}} // nebula::meta::cpp2 diff --git a/src/interface/gen-cpp2/MetaServiceAsyncClient.h b/src/interface/gen-cpp2/MetaServiceAsyncClient.h new file mode 100644 index 00000000..b332387d --- /dev/null +++ b/src/interface/gen-cpp2/MetaServiceAsyncClient.h @@ -0,0 +1,7413 @@ +/** + * Autogenerated by Thrift for meta.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#pragma once + +#include + +#include "meta_types.h" +#include "common_types.h" + +namespace apache { namespace thrift { + class Cpp2RequestContext; + namespace detail { namespace ac { struct ClientRequestContext; }} + namespace transport { class THeader; } +}} + +namespace nebula { namespace meta { namespace cpp2 { + +class MetaServiceAsyncClient : public apache::thrift::GeneratedAsyncClient { + public: + using apache::thrift::GeneratedAsyncClient::GeneratedAsyncClient; + + char const* getServiceName() const noexcept override { + return "MetaService"; + } + + + virtual void createSpace(std::unique_ptr callback, const ::nebula::meta::cpp2::CreateSpaceReq& p_req); + virtual void createSpace(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::CreateSpaceReq& p_req); + protected: + void createSpaceImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::CreateSpaceReq& p_req); + public: + + virtual void sync_createSpace( ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::CreateSpaceReq& p_req); + virtual void sync_createSpace(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::CreateSpaceReq& p_req); + + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_createSpace(const ::nebula::meta::cpp2::CreateSpaceReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_createSpace(const ::nebula::meta::cpp2::CreateSpaceReq& p_req); + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_createSpace(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateSpaceReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_createSpace(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateSpaceReq& p_req); + virtual folly::Future>> header_future_createSpace(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateSpaceReq& p_req); + virtual folly::SemiFuture>> header_semifuture_createSpace(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateSpaceReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_createSpace(const ::nebula::meta::cpp2::CreateSpaceReq& p_req) { + return co_createSpace(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_createSpace(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateSpaceReq& p_req) { + return co_createSpace(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_createSpace(apache::thrift::RpcOptions* rpcOptions, const ::nebula::meta::cpp2::CreateSpaceReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = createSpaceCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + createSpaceImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + createSpaceImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::meta::cpp2::ExecResp _return; + if (auto ew = recv_wrapped_createSpace(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void createSpace(folly::Function callback, const ::nebula::meta::cpp2::CreateSpaceReq& p_req); + + + static folly::exception_wrapper recv_wrapped_createSpace( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_createSpace( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_createSpace( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_createSpace( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void createSpaceT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::CreateSpaceReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> createSpaceCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void dropSpace(std::unique_ptr callback, const ::nebula::meta::cpp2::DropSpaceReq& p_req); + virtual void dropSpace(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::DropSpaceReq& p_req); + protected: + void dropSpaceImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::DropSpaceReq& p_req); + public: + + virtual void sync_dropSpace( ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::DropSpaceReq& p_req); + virtual void sync_dropSpace(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::DropSpaceReq& p_req); + + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_dropSpace(const ::nebula::meta::cpp2::DropSpaceReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_dropSpace(const ::nebula::meta::cpp2::DropSpaceReq& p_req); + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_dropSpace(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropSpaceReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_dropSpace(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropSpaceReq& p_req); + virtual folly::Future>> header_future_dropSpace(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropSpaceReq& p_req); + virtual folly::SemiFuture>> header_semifuture_dropSpace(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropSpaceReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_dropSpace(const ::nebula::meta::cpp2::DropSpaceReq& p_req) { + return co_dropSpace(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_dropSpace(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropSpaceReq& p_req) { + return co_dropSpace(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_dropSpace(apache::thrift::RpcOptions* rpcOptions, const ::nebula::meta::cpp2::DropSpaceReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = dropSpaceCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + dropSpaceImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + dropSpaceImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::meta::cpp2::ExecResp _return; + if (auto ew = recv_wrapped_dropSpace(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void dropSpace(folly::Function callback, const ::nebula::meta::cpp2::DropSpaceReq& p_req); + + + static folly::exception_wrapper recv_wrapped_dropSpace( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_dropSpace( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_dropSpace( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_dropSpace( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void dropSpaceT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::DropSpaceReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> dropSpaceCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void getSpace(std::unique_ptr callback, const ::nebula::meta::cpp2::GetSpaceReq& p_req); + virtual void getSpace(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::GetSpaceReq& p_req); + protected: + void getSpaceImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::GetSpaceReq& p_req); + public: + + virtual void sync_getSpace( ::nebula::meta::cpp2::GetSpaceResp& _return, const ::nebula::meta::cpp2::GetSpaceReq& p_req); + virtual void sync_getSpace(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::GetSpaceResp& _return, const ::nebula::meta::cpp2::GetSpaceReq& p_req); + + virtual folly::Future< ::nebula::meta::cpp2::GetSpaceResp> future_getSpace(const ::nebula::meta::cpp2::GetSpaceReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::GetSpaceResp> semifuture_getSpace(const ::nebula::meta::cpp2::GetSpaceReq& p_req); + virtual folly::Future< ::nebula::meta::cpp2::GetSpaceResp> future_getSpace(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetSpaceReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::GetSpaceResp> semifuture_getSpace(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetSpaceReq& p_req); + virtual folly::Future>> header_future_getSpace(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetSpaceReq& p_req); + virtual folly::SemiFuture>> header_semifuture_getSpace(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetSpaceReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::meta::cpp2::GetSpaceResp> co_getSpace(const ::nebula::meta::cpp2::GetSpaceReq& p_req) { + return co_getSpace(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::meta::cpp2::GetSpaceResp> co_getSpace(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetSpaceReq& p_req) { + return co_getSpace(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::meta::cpp2::GetSpaceResp> co_getSpace(apache::thrift::RpcOptions* rpcOptions, const ::nebula::meta::cpp2::GetSpaceReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = getSpaceCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + getSpaceImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + getSpaceImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::meta::cpp2::GetSpaceResp _return; + if (auto ew = recv_wrapped_getSpace(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void getSpace(folly::Function callback, const ::nebula::meta::cpp2::GetSpaceReq& p_req); + + + static folly::exception_wrapper recv_wrapped_getSpace( ::nebula::meta::cpp2::GetSpaceResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_getSpace( ::nebula::meta::cpp2::GetSpaceResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_getSpace( ::nebula::meta::cpp2::GetSpaceResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_getSpace( ::nebula::meta::cpp2::GetSpaceResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void getSpaceT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::GetSpaceReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> getSpaceCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void listSpaces(std::unique_ptr callback, const ::nebula::meta::cpp2::ListSpacesReq& p_req); + virtual void listSpaces(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::ListSpacesReq& p_req); + protected: + void listSpacesImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::ListSpacesReq& p_req); + public: + + virtual void sync_listSpaces( ::nebula::meta::cpp2::ListSpacesResp& _return, const ::nebula::meta::cpp2::ListSpacesReq& p_req); + virtual void sync_listSpaces(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ListSpacesResp& _return, const ::nebula::meta::cpp2::ListSpacesReq& p_req); + + virtual folly::Future< ::nebula::meta::cpp2::ListSpacesResp> future_listSpaces(const ::nebula::meta::cpp2::ListSpacesReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ListSpacesResp> semifuture_listSpaces(const ::nebula::meta::cpp2::ListSpacesReq& p_req); + virtual folly::Future< ::nebula::meta::cpp2::ListSpacesResp> future_listSpaces(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListSpacesReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ListSpacesResp> semifuture_listSpaces(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListSpacesReq& p_req); + virtual folly::Future>> header_future_listSpaces(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListSpacesReq& p_req); + virtual folly::SemiFuture>> header_semifuture_listSpaces(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListSpacesReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::meta::cpp2::ListSpacesResp> co_listSpaces(const ::nebula::meta::cpp2::ListSpacesReq& p_req) { + return co_listSpaces(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::meta::cpp2::ListSpacesResp> co_listSpaces(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListSpacesReq& p_req) { + return co_listSpaces(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::meta::cpp2::ListSpacesResp> co_listSpaces(apache::thrift::RpcOptions* rpcOptions, const ::nebula::meta::cpp2::ListSpacesReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = listSpacesCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + listSpacesImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + listSpacesImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::meta::cpp2::ListSpacesResp _return; + if (auto ew = recv_wrapped_listSpaces(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void listSpaces(folly::Function callback, const ::nebula::meta::cpp2::ListSpacesReq& p_req); + + + static folly::exception_wrapper recv_wrapped_listSpaces( ::nebula::meta::cpp2::ListSpacesResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_listSpaces( ::nebula::meta::cpp2::ListSpacesResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_listSpaces( ::nebula::meta::cpp2::ListSpacesResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_listSpaces( ::nebula::meta::cpp2::ListSpacesResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void listSpacesT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::ListSpacesReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> listSpacesCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void createSpaceAs(std::unique_ptr callback, const ::nebula::meta::cpp2::CreateSpaceAsReq& p_req); + virtual void createSpaceAs(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::CreateSpaceAsReq& p_req); + protected: + void createSpaceAsImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::CreateSpaceAsReq& p_req); + public: + + virtual void sync_createSpaceAs( ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::CreateSpaceAsReq& p_req); + virtual void sync_createSpaceAs(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::CreateSpaceAsReq& p_req); + + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_createSpaceAs(const ::nebula::meta::cpp2::CreateSpaceAsReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_createSpaceAs(const ::nebula::meta::cpp2::CreateSpaceAsReq& p_req); + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_createSpaceAs(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateSpaceAsReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_createSpaceAs(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateSpaceAsReq& p_req); + virtual folly::Future>> header_future_createSpaceAs(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateSpaceAsReq& p_req); + virtual folly::SemiFuture>> header_semifuture_createSpaceAs(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateSpaceAsReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_createSpaceAs(const ::nebula::meta::cpp2::CreateSpaceAsReq& p_req) { + return co_createSpaceAs(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_createSpaceAs(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateSpaceAsReq& p_req) { + return co_createSpaceAs(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_createSpaceAs(apache::thrift::RpcOptions* rpcOptions, const ::nebula::meta::cpp2::CreateSpaceAsReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = createSpaceAsCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + createSpaceAsImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + createSpaceAsImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::meta::cpp2::ExecResp _return; + if (auto ew = recv_wrapped_createSpaceAs(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void createSpaceAs(folly::Function callback, const ::nebula::meta::cpp2::CreateSpaceAsReq& p_req); + + + static folly::exception_wrapper recv_wrapped_createSpaceAs( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_createSpaceAs( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_createSpaceAs( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_createSpaceAs( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void createSpaceAsT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::CreateSpaceAsReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> createSpaceAsCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void createTag(std::unique_ptr callback, const ::nebula::meta::cpp2::CreateTagReq& p_req); + virtual void createTag(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::CreateTagReq& p_req); + protected: + void createTagImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::CreateTagReq& p_req); + public: + + virtual void sync_createTag( ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::CreateTagReq& p_req); + virtual void sync_createTag(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::CreateTagReq& p_req); + + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_createTag(const ::nebula::meta::cpp2::CreateTagReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_createTag(const ::nebula::meta::cpp2::CreateTagReq& p_req); + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_createTag(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateTagReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_createTag(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateTagReq& p_req); + virtual folly::Future>> header_future_createTag(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateTagReq& p_req); + virtual folly::SemiFuture>> header_semifuture_createTag(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateTagReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_createTag(const ::nebula::meta::cpp2::CreateTagReq& p_req) { + return co_createTag(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_createTag(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateTagReq& p_req) { + return co_createTag(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_createTag(apache::thrift::RpcOptions* rpcOptions, const ::nebula::meta::cpp2::CreateTagReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = createTagCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + createTagImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + createTagImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::meta::cpp2::ExecResp _return; + if (auto ew = recv_wrapped_createTag(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void createTag(folly::Function callback, const ::nebula::meta::cpp2::CreateTagReq& p_req); + + + static folly::exception_wrapper recv_wrapped_createTag( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_createTag( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_createTag( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_createTag( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void createTagT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::CreateTagReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> createTagCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void alterTag(std::unique_ptr callback, const ::nebula::meta::cpp2::AlterTagReq& p_req); + virtual void alterTag(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::AlterTagReq& p_req); + protected: + void alterTagImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::AlterTagReq& p_req); + public: + + virtual void sync_alterTag( ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::AlterTagReq& p_req); + virtual void sync_alterTag(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::AlterTagReq& p_req); + + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_alterTag(const ::nebula::meta::cpp2::AlterTagReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_alterTag(const ::nebula::meta::cpp2::AlterTagReq& p_req); + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_alterTag(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::AlterTagReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_alterTag(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::AlterTagReq& p_req); + virtual folly::Future>> header_future_alterTag(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::AlterTagReq& p_req); + virtual folly::SemiFuture>> header_semifuture_alterTag(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::AlterTagReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_alterTag(const ::nebula::meta::cpp2::AlterTagReq& p_req) { + return co_alterTag(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_alterTag(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::AlterTagReq& p_req) { + return co_alterTag(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_alterTag(apache::thrift::RpcOptions* rpcOptions, const ::nebula::meta::cpp2::AlterTagReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = alterTagCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + alterTagImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + alterTagImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::meta::cpp2::ExecResp _return; + if (auto ew = recv_wrapped_alterTag(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void alterTag(folly::Function callback, const ::nebula::meta::cpp2::AlterTagReq& p_req); + + + static folly::exception_wrapper recv_wrapped_alterTag( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_alterTag( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_alterTag( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_alterTag( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void alterTagT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::AlterTagReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> alterTagCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void dropTag(std::unique_ptr callback, const ::nebula::meta::cpp2::DropTagReq& p_req); + virtual void dropTag(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::DropTagReq& p_req); + protected: + void dropTagImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::DropTagReq& p_req); + public: + + virtual void sync_dropTag( ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::DropTagReq& p_req); + virtual void sync_dropTag(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::DropTagReq& p_req); + + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_dropTag(const ::nebula::meta::cpp2::DropTagReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_dropTag(const ::nebula::meta::cpp2::DropTagReq& p_req); + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_dropTag(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropTagReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_dropTag(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropTagReq& p_req); + virtual folly::Future>> header_future_dropTag(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropTagReq& p_req); + virtual folly::SemiFuture>> header_semifuture_dropTag(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropTagReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_dropTag(const ::nebula::meta::cpp2::DropTagReq& p_req) { + return co_dropTag(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_dropTag(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropTagReq& p_req) { + return co_dropTag(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_dropTag(apache::thrift::RpcOptions* rpcOptions, const ::nebula::meta::cpp2::DropTagReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = dropTagCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + dropTagImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + dropTagImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::meta::cpp2::ExecResp _return; + if (auto ew = recv_wrapped_dropTag(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void dropTag(folly::Function callback, const ::nebula::meta::cpp2::DropTagReq& p_req); + + + static folly::exception_wrapper recv_wrapped_dropTag( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_dropTag( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_dropTag( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_dropTag( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void dropTagT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::DropTagReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> dropTagCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void getTag(std::unique_ptr callback, const ::nebula::meta::cpp2::GetTagReq& p_req); + virtual void getTag(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::GetTagReq& p_req); + protected: + void getTagImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::GetTagReq& p_req); + public: + + virtual void sync_getTag( ::nebula::meta::cpp2::GetTagResp& _return, const ::nebula::meta::cpp2::GetTagReq& p_req); + virtual void sync_getTag(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::GetTagResp& _return, const ::nebula::meta::cpp2::GetTagReq& p_req); + + virtual folly::Future< ::nebula::meta::cpp2::GetTagResp> future_getTag(const ::nebula::meta::cpp2::GetTagReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::GetTagResp> semifuture_getTag(const ::nebula::meta::cpp2::GetTagReq& p_req); + virtual folly::Future< ::nebula::meta::cpp2::GetTagResp> future_getTag(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetTagReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::GetTagResp> semifuture_getTag(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetTagReq& p_req); + virtual folly::Future>> header_future_getTag(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetTagReq& p_req); + virtual folly::SemiFuture>> header_semifuture_getTag(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetTagReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::meta::cpp2::GetTagResp> co_getTag(const ::nebula::meta::cpp2::GetTagReq& p_req) { + return co_getTag(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::meta::cpp2::GetTagResp> co_getTag(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetTagReq& p_req) { + return co_getTag(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::meta::cpp2::GetTagResp> co_getTag(apache::thrift::RpcOptions* rpcOptions, const ::nebula::meta::cpp2::GetTagReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = getTagCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + getTagImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + getTagImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::meta::cpp2::GetTagResp _return; + if (auto ew = recv_wrapped_getTag(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void getTag(folly::Function callback, const ::nebula::meta::cpp2::GetTagReq& p_req); + + + static folly::exception_wrapper recv_wrapped_getTag( ::nebula::meta::cpp2::GetTagResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_getTag( ::nebula::meta::cpp2::GetTagResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_getTag( ::nebula::meta::cpp2::GetTagResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_getTag( ::nebula::meta::cpp2::GetTagResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void getTagT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::GetTagReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> getTagCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void listTags(std::unique_ptr callback, const ::nebula::meta::cpp2::ListTagsReq& p_req); + virtual void listTags(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::ListTagsReq& p_req); + protected: + void listTagsImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::ListTagsReq& p_req); + public: + + virtual void sync_listTags( ::nebula::meta::cpp2::ListTagsResp& _return, const ::nebula::meta::cpp2::ListTagsReq& p_req); + virtual void sync_listTags(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ListTagsResp& _return, const ::nebula::meta::cpp2::ListTagsReq& p_req); + + virtual folly::Future< ::nebula::meta::cpp2::ListTagsResp> future_listTags(const ::nebula::meta::cpp2::ListTagsReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ListTagsResp> semifuture_listTags(const ::nebula::meta::cpp2::ListTagsReq& p_req); + virtual folly::Future< ::nebula::meta::cpp2::ListTagsResp> future_listTags(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListTagsReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ListTagsResp> semifuture_listTags(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListTagsReq& p_req); + virtual folly::Future>> header_future_listTags(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListTagsReq& p_req); + virtual folly::SemiFuture>> header_semifuture_listTags(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListTagsReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::meta::cpp2::ListTagsResp> co_listTags(const ::nebula::meta::cpp2::ListTagsReq& p_req) { + return co_listTags(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::meta::cpp2::ListTagsResp> co_listTags(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListTagsReq& p_req) { + return co_listTags(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::meta::cpp2::ListTagsResp> co_listTags(apache::thrift::RpcOptions* rpcOptions, const ::nebula::meta::cpp2::ListTagsReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = listTagsCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + listTagsImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + listTagsImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::meta::cpp2::ListTagsResp _return; + if (auto ew = recv_wrapped_listTags(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void listTags(folly::Function callback, const ::nebula::meta::cpp2::ListTagsReq& p_req); + + + static folly::exception_wrapper recv_wrapped_listTags( ::nebula::meta::cpp2::ListTagsResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_listTags( ::nebula::meta::cpp2::ListTagsResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_listTags( ::nebula::meta::cpp2::ListTagsResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_listTags( ::nebula::meta::cpp2::ListTagsResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void listTagsT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::ListTagsReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> listTagsCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void createEdge(std::unique_ptr callback, const ::nebula::meta::cpp2::CreateEdgeReq& p_req); + virtual void createEdge(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::CreateEdgeReq& p_req); + protected: + void createEdgeImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::CreateEdgeReq& p_req); + public: + + virtual void sync_createEdge( ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::CreateEdgeReq& p_req); + virtual void sync_createEdge(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::CreateEdgeReq& p_req); + + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_createEdge(const ::nebula::meta::cpp2::CreateEdgeReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_createEdge(const ::nebula::meta::cpp2::CreateEdgeReq& p_req); + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_createEdge(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateEdgeReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_createEdge(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateEdgeReq& p_req); + virtual folly::Future>> header_future_createEdge(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateEdgeReq& p_req); + virtual folly::SemiFuture>> header_semifuture_createEdge(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateEdgeReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_createEdge(const ::nebula::meta::cpp2::CreateEdgeReq& p_req) { + return co_createEdge(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_createEdge(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateEdgeReq& p_req) { + return co_createEdge(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_createEdge(apache::thrift::RpcOptions* rpcOptions, const ::nebula::meta::cpp2::CreateEdgeReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = createEdgeCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + createEdgeImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + createEdgeImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::meta::cpp2::ExecResp _return; + if (auto ew = recv_wrapped_createEdge(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void createEdge(folly::Function callback, const ::nebula::meta::cpp2::CreateEdgeReq& p_req); + + + static folly::exception_wrapper recv_wrapped_createEdge( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_createEdge( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_createEdge( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_createEdge( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void createEdgeT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::CreateEdgeReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> createEdgeCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void alterEdge(std::unique_ptr callback, const ::nebula::meta::cpp2::AlterEdgeReq& p_req); + virtual void alterEdge(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::AlterEdgeReq& p_req); + protected: + void alterEdgeImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::AlterEdgeReq& p_req); + public: + + virtual void sync_alterEdge( ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::AlterEdgeReq& p_req); + virtual void sync_alterEdge(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::AlterEdgeReq& p_req); + + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_alterEdge(const ::nebula::meta::cpp2::AlterEdgeReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_alterEdge(const ::nebula::meta::cpp2::AlterEdgeReq& p_req); + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_alterEdge(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::AlterEdgeReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_alterEdge(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::AlterEdgeReq& p_req); + virtual folly::Future>> header_future_alterEdge(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::AlterEdgeReq& p_req); + virtual folly::SemiFuture>> header_semifuture_alterEdge(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::AlterEdgeReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_alterEdge(const ::nebula::meta::cpp2::AlterEdgeReq& p_req) { + return co_alterEdge(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_alterEdge(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::AlterEdgeReq& p_req) { + return co_alterEdge(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_alterEdge(apache::thrift::RpcOptions* rpcOptions, const ::nebula::meta::cpp2::AlterEdgeReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = alterEdgeCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + alterEdgeImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + alterEdgeImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::meta::cpp2::ExecResp _return; + if (auto ew = recv_wrapped_alterEdge(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void alterEdge(folly::Function callback, const ::nebula::meta::cpp2::AlterEdgeReq& p_req); + + + static folly::exception_wrapper recv_wrapped_alterEdge( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_alterEdge( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_alterEdge( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_alterEdge( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void alterEdgeT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::AlterEdgeReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> alterEdgeCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void dropEdge(std::unique_ptr callback, const ::nebula::meta::cpp2::DropEdgeReq& p_req); + virtual void dropEdge(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::DropEdgeReq& p_req); + protected: + void dropEdgeImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::DropEdgeReq& p_req); + public: + + virtual void sync_dropEdge( ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::DropEdgeReq& p_req); + virtual void sync_dropEdge(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::DropEdgeReq& p_req); + + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_dropEdge(const ::nebula::meta::cpp2::DropEdgeReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_dropEdge(const ::nebula::meta::cpp2::DropEdgeReq& p_req); + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_dropEdge(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropEdgeReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_dropEdge(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropEdgeReq& p_req); + virtual folly::Future>> header_future_dropEdge(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropEdgeReq& p_req); + virtual folly::SemiFuture>> header_semifuture_dropEdge(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropEdgeReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_dropEdge(const ::nebula::meta::cpp2::DropEdgeReq& p_req) { + return co_dropEdge(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_dropEdge(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropEdgeReq& p_req) { + return co_dropEdge(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_dropEdge(apache::thrift::RpcOptions* rpcOptions, const ::nebula::meta::cpp2::DropEdgeReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = dropEdgeCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + dropEdgeImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + dropEdgeImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::meta::cpp2::ExecResp _return; + if (auto ew = recv_wrapped_dropEdge(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void dropEdge(folly::Function callback, const ::nebula::meta::cpp2::DropEdgeReq& p_req); + + + static folly::exception_wrapper recv_wrapped_dropEdge( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_dropEdge( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_dropEdge( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_dropEdge( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void dropEdgeT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::DropEdgeReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> dropEdgeCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void getEdge(std::unique_ptr callback, const ::nebula::meta::cpp2::GetEdgeReq& p_req); + virtual void getEdge(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::GetEdgeReq& p_req); + protected: + void getEdgeImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::GetEdgeReq& p_req); + public: + + virtual void sync_getEdge( ::nebula::meta::cpp2::GetEdgeResp& _return, const ::nebula::meta::cpp2::GetEdgeReq& p_req); + virtual void sync_getEdge(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::GetEdgeResp& _return, const ::nebula::meta::cpp2::GetEdgeReq& p_req); + + virtual folly::Future< ::nebula::meta::cpp2::GetEdgeResp> future_getEdge(const ::nebula::meta::cpp2::GetEdgeReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::GetEdgeResp> semifuture_getEdge(const ::nebula::meta::cpp2::GetEdgeReq& p_req); + virtual folly::Future< ::nebula::meta::cpp2::GetEdgeResp> future_getEdge(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetEdgeReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::GetEdgeResp> semifuture_getEdge(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetEdgeReq& p_req); + virtual folly::Future>> header_future_getEdge(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetEdgeReq& p_req); + virtual folly::SemiFuture>> header_semifuture_getEdge(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetEdgeReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::meta::cpp2::GetEdgeResp> co_getEdge(const ::nebula::meta::cpp2::GetEdgeReq& p_req) { + return co_getEdge(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::meta::cpp2::GetEdgeResp> co_getEdge(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetEdgeReq& p_req) { + return co_getEdge(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::meta::cpp2::GetEdgeResp> co_getEdge(apache::thrift::RpcOptions* rpcOptions, const ::nebula::meta::cpp2::GetEdgeReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = getEdgeCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + getEdgeImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + getEdgeImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::meta::cpp2::GetEdgeResp _return; + if (auto ew = recv_wrapped_getEdge(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void getEdge(folly::Function callback, const ::nebula::meta::cpp2::GetEdgeReq& p_req); + + + static folly::exception_wrapper recv_wrapped_getEdge( ::nebula::meta::cpp2::GetEdgeResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_getEdge( ::nebula::meta::cpp2::GetEdgeResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_getEdge( ::nebula::meta::cpp2::GetEdgeResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_getEdge( ::nebula::meta::cpp2::GetEdgeResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void getEdgeT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::GetEdgeReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> getEdgeCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void listEdges(std::unique_ptr callback, const ::nebula::meta::cpp2::ListEdgesReq& p_req); + virtual void listEdges(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::ListEdgesReq& p_req); + protected: + void listEdgesImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::ListEdgesReq& p_req); + public: + + virtual void sync_listEdges( ::nebula::meta::cpp2::ListEdgesResp& _return, const ::nebula::meta::cpp2::ListEdgesReq& p_req); + virtual void sync_listEdges(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ListEdgesResp& _return, const ::nebula::meta::cpp2::ListEdgesReq& p_req); + + virtual folly::Future< ::nebula::meta::cpp2::ListEdgesResp> future_listEdges(const ::nebula::meta::cpp2::ListEdgesReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ListEdgesResp> semifuture_listEdges(const ::nebula::meta::cpp2::ListEdgesReq& p_req); + virtual folly::Future< ::nebula::meta::cpp2::ListEdgesResp> future_listEdges(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListEdgesReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ListEdgesResp> semifuture_listEdges(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListEdgesReq& p_req); + virtual folly::Future>> header_future_listEdges(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListEdgesReq& p_req); + virtual folly::SemiFuture>> header_semifuture_listEdges(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListEdgesReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::meta::cpp2::ListEdgesResp> co_listEdges(const ::nebula::meta::cpp2::ListEdgesReq& p_req) { + return co_listEdges(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::meta::cpp2::ListEdgesResp> co_listEdges(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListEdgesReq& p_req) { + return co_listEdges(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::meta::cpp2::ListEdgesResp> co_listEdges(apache::thrift::RpcOptions* rpcOptions, const ::nebula::meta::cpp2::ListEdgesReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = listEdgesCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + listEdgesImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + listEdgesImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::meta::cpp2::ListEdgesResp _return; + if (auto ew = recv_wrapped_listEdges(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void listEdges(folly::Function callback, const ::nebula::meta::cpp2::ListEdgesReq& p_req); + + + static folly::exception_wrapper recv_wrapped_listEdges( ::nebula::meta::cpp2::ListEdgesResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_listEdges( ::nebula::meta::cpp2::ListEdgesResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_listEdges( ::nebula::meta::cpp2::ListEdgesResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_listEdges( ::nebula::meta::cpp2::ListEdgesResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void listEdgesT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::ListEdgesReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> listEdgesCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void listHosts(std::unique_ptr callback, const ::nebula::meta::cpp2::ListHostsReq& p_req); + virtual void listHosts(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::ListHostsReq& p_req); + protected: + void listHostsImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::ListHostsReq& p_req); + public: + + virtual void sync_listHosts( ::nebula::meta::cpp2::ListHostsResp& _return, const ::nebula::meta::cpp2::ListHostsReq& p_req); + virtual void sync_listHosts(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ListHostsResp& _return, const ::nebula::meta::cpp2::ListHostsReq& p_req); + + virtual folly::Future< ::nebula::meta::cpp2::ListHostsResp> future_listHosts(const ::nebula::meta::cpp2::ListHostsReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ListHostsResp> semifuture_listHosts(const ::nebula::meta::cpp2::ListHostsReq& p_req); + virtual folly::Future< ::nebula::meta::cpp2::ListHostsResp> future_listHosts(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListHostsReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ListHostsResp> semifuture_listHosts(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListHostsReq& p_req); + virtual folly::Future>> header_future_listHosts(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListHostsReq& p_req); + virtual folly::SemiFuture>> header_semifuture_listHosts(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListHostsReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::meta::cpp2::ListHostsResp> co_listHosts(const ::nebula::meta::cpp2::ListHostsReq& p_req) { + return co_listHosts(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::meta::cpp2::ListHostsResp> co_listHosts(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListHostsReq& p_req) { + return co_listHosts(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::meta::cpp2::ListHostsResp> co_listHosts(apache::thrift::RpcOptions* rpcOptions, const ::nebula::meta::cpp2::ListHostsReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = listHostsCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + listHostsImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + listHostsImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::meta::cpp2::ListHostsResp _return; + if (auto ew = recv_wrapped_listHosts(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void listHosts(folly::Function callback, const ::nebula::meta::cpp2::ListHostsReq& p_req); + + + static folly::exception_wrapper recv_wrapped_listHosts( ::nebula::meta::cpp2::ListHostsResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_listHosts( ::nebula::meta::cpp2::ListHostsResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_listHosts( ::nebula::meta::cpp2::ListHostsResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_listHosts( ::nebula::meta::cpp2::ListHostsResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void listHostsT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::ListHostsReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> listHostsCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void getPartsAlloc(std::unique_ptr callback, const ::nebula::meta::cpp2::GetPartsAllocReq& p_req); + virtual void getPartsAlloc(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::GetPartsAllocReq& p_req); + protected: + void getPartsAllocImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::GetPartsAllocReq& p_req); + public: + + virtual void sync_getPartsAlloc( ::nebula::meta::cpp2::GetPartsAllocResp& _return, const ::nebula::meta::cpp2::GetPartsAllocReq& p_req); + virtual void sync_getPartsAlloc(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::GetPartsAllocResp& _return, const ::nebula::meta::cpp2::GetPartsAllocReq& p_req); + + virtual folly::Future< ::nebula::meta::cpp2::GetPartsAllocResp> future_getPartsAlloc(const ::nebula::meta::cpp2::GetPartsAllocReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::GetPartsAllocResp> semifuture_getPartsAlloc(const ::nebula::meta::cpp2::GetPartsAllocReq& p_req); + virtual folly::Future< ::nebula::meta::cpp2::GetPartsAllocResp> future_getPartsAlloc(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetPartsAllocReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::GetPartsAllocResp> semifuture_getPartsAlloc(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetPartsAllocReq& p_req); + virtual folly::Future>> header_future_getPartsAlloc(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetPartsAllocReq& p_req); + virtual folly::SemiFuture>> header_semifuture_getPartsAlloc(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetPartsAllocReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::meta::cpp2::GetPartsAllocResp> co_getPartsAlloc(const ::nebula::meta::cpp2::GetPartsAllocReq& p_req) { + return co_getPartsAlloc(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::meta::cpp2::GetPartsAllocResp> co_getPartsAlloc(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetPartsAllocReq& p_req) { + return co_getPartsAlloc(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::meta::cpp2::GetPartsAllocResp> co_getPartsAlloc(apache::thrift::RpcOptions* rpcOptions, const ::nebula::meta::cpp2::GetPartsAllocReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = getPartsAllocCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + getPartsAllocImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + getPartsAllocImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::meta::cpp2::GetPartsAllocResp _return; + if (auto ew = recv_wrapped_getPartsAlloc(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void getPartsAlloc(folly::Function callback, const ::nebula::meta::cpp2::GetPartsAllocReq& p_req); + + + static folly::exception_wrapper recv_wrapped_getPartsAlloc( ::nebula::meta::cpp2::GetPartsAllocResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_getPartsAlloc( ::nebula::meta::cpp2::GetPartsAllocResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_getPartsAlloc( ::nebula::meta::cpp2::GetPartsAllocResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_getPartsAlloc( ::nebula::meta::cpp2::GetPartsAllocResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void getPartsAllocT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::GetPartsAllocReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> getPartsAllocCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void listParts(std::unique_ptr callback, const ::nebula::meta::cpp2::ListPartsReq& p_req); + virtual void listParts(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::ListPartsReq& p_req); + protected: + void listPartsImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::ListPartsReq& p_req); + public: + + virtual void sync_listParts( ::nebula::meta::cpp2::ListPartsResp& _return, const ::nebula::meta::cpp2::ListPartsReq& p_req); + virtual void sync_listParts(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ListPartsResp& _return, const ::nebula::meta::cpp2::ListPartsReq& p_req); + + virtual folly::Future< ::nebula::meta::cpp2::ListPartsResp> future_listParts(const ::nebula::meta::cpp2::ListPartsReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ListPartsResp> semifuture_listParts(const ::nebula::meta::cpp2::ListPartsReq& p_req); + virtual folly::Future< ::nebula::meta::cpp2::ListPartsResp> future_listParts(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListPartsReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ListPartsResp> semifuture_listParts(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListPartsReq& p_req); + virtual folly::Future>> header_future_listParts(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListPartsReq& p_req); + virtual folly::SemiFuture>> header_semifuture_listParts(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListPartsReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::meta::cpp2::ListPartsResp> co_listParts(const ::nebula::meta::cpp2::ListPartsReq& p_req) { + return co_listParts(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::meta::cpp2::ListPartsResp> co_listParts(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListPartsReq& p_req) { + return co_listParts(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::meta::cpp2::ListPartsResp> co_listParts(apache::thrift::RpcOptions* rpcOptions, const ::nebula::meta::cpp2::ListPartsReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = listPartsCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + listPartsImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + listPartsImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::meta::cpp2::ListPartsResp _return; + if (auto ew = recv_wrapped_listParts(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void listParts(folly::Function callback, const ::nebula::meta::cpp2::ListPartsReq& p_req); + + + static folly::exception_wrapper recv_wrapped_listParts( ::nebula::meta::cpp2::ListPartsResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_listParts( ::nebula::meta::cpp2::ListPartsResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_listParts( ::nebula::meta::cpp2::ListPartsResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_listParts( ::nebula::meta::cpp2::ListPartsResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void listPartsT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::ListPartsReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> listPartsCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void multiPut(std::unique_ptr callback, const ::nebula::meta::cpp2::MultiPutReq& p_req); + virtual void multiPut(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::MultiPutReq& p_req); + protected: + void multiPutImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::MultiPutReq& p_req); + public: + + virtual void sync_multiPut( ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::MultiPutReq& p_req); + virtual void sync_multiPut(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::MultiPutReq& p_req); + + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_multiPut(const ::nebula::meta::cpp2::MultiPutReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_multiPut(const ::nebula::meta::cpp2::MultiPutReq& p_req); + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_multiPut(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::MultiPutReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_multiPut(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::MultiPutReq& p_req); + virtual folly::Future>> header_future_multiPut(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::MultiPutReq& p_req); + virtual folly::SemiFuture>> header_semifuture_multiPut(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::MultiPutReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_multiPut(const ::nebula::meta::cpp2::MultiPutReq& p_req) { + return co_multiPut(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_multiPut(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::MultiPutReq& p_req) { + return co_multiPut(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_multiPut(apache::thrift::RpcOptions* rpcOptions, const ::nebula::meta::cpp2::MultiPutReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = multiPutCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + multiPutImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + multiPutImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::meta::cpp2::ExecResp _return; + if (auto ew = recv_wrapped_multiPut(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void multiPut(folly::Function callback, const ::nebula::meta::cpp2::MultiPutReq& p_req); + + + static folly::exception_wrapper recv_wrapped_multiPut( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_multiPut( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_multiPut( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_multiPut( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void multiPutT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::MultiPutReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> multiPutCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void get(std::unique_ptr callback, const ::nebula::meta::cpp2::GetReq& p_req); + virtual void get(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::GetReq& p_req); + protected: + void getImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::GetReq& p_req); + public: + + virtual void sync_get( ::nebula::meta::cpp2::GetResp& _return, const ::nebula::meta::cpp2::GetReq& p_req); + virtual void sync_get(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::GetResp& _return, const ::nebula::meta::cpp2::GetReq& p_req); + + virtual folly::Future< ::nebula::meta::cpp2::GetResp> future_get(const ::nebula::meta::cpp2::GetReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::GetResp> semifuture_get(const ::nebula::meta::cpp2::GetReq& p_req); + virtual folly::Future< ::nebula::meta::cpp2::GetResp> future_get(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::GetResp> semifuture_get(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetReq& p_req); + virtual folly::Future>> header_future_get(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetReq& p_req); + virtual folly::SemiFuture>> header_semifuture_get(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::meta::cpp2::GetResp> co_get(const ::nebula::meta::cpp2::GetReq& p_req) { + return co_get(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::meta::cpp2::GetResp> co_get(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetReq& p_req) { + return co_get(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::meta::cpp2::GetResp> co_get(apache::thrift::RpcOptions* rpcOptions, const ::nebula::meta::cpp2::GetReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = getCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + getImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + getImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::meta::cpp2::GetResp _return; + if (auto ew = recv_wrapped_get(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void get(folly::Function callback, const ::nebula::meta::cpp2::GetReq& p_req); + + + static folly::exception_wrapper recv_wrapped_get( ::nebula::meta::cpp2::GetResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_get( ::nebula::meta::cpp2::GetResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_get( ::nebula::meta::cpp2::GetResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_get( ::nebula::meta::cpp2::GetResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void getT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::GetReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> getCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void multiGet(std::unique_ptr callback, const ::nebula::meta::cpp2::MultiGetReq& p_req); + virtual void multiGet(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::MultiGetReq& p_req); + protected: + void multiGetImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::MultiGetReq& p_req); + public: + + virtual void sync_multiGet( ::nebula::meta::cpp2::MultiGetResp& _return, const ::nebula::meta::cpp2::MultiGetReq& p_req); + virtual void sync_multiGet(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::MultiGetResp& _return, const ::nebula::meta::cpp2::MultiGetReq& p_req); + + virtual folly::Future< ::nebula::meta::cpp2::MultiGetResp> future_multiGet(const ::nebula::meta::cpp2::MultiGetReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::MultiGetResp> semifuture_multiGet(const ::nebula::meta::cpp2::MultiGetReq& p_req); + virtual folly::Future< ::nebula::meta::cpp2::MultiGetResp> future_multiGet(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::MultiGetReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::MultiGetResp> semifuture_multiGet(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::MultiGetReq& p_req); + virtual folly::Future>> header_future_multiGet(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::MultiGetReq& p_req); + virtual folly::SemiFuture>> header_semifuture_multiGet(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::MultiGetReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::meta::cpp2::MultiGetResp> co_multiGet(const ::nebula::meta::cpp2::MultiGetReq& p_req) { + return co_multiGet(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::meta::cpp2::MultiGetResp> co_multiGet(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::MultiGetReq& p_req) { + return co_multiGet(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::meta::cpp2::MultiGetResp> co_multiGet(apache::thrift::RpcOptions* rpcOptions, const ::nebula::meta::cpp2::MultiGetReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = multiGetCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + multiGetImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + multiGetImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::meta::cpp2::MultiGetResp _return; + if (auto ew = recv_wrapped_multiGet(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void multiGet(folly::Function callback, const ::nebula::meta::cpp2::MultiGetReq& p_req); + + + static folly::exception_wrapper recv_wrapped_multiGet( ::nebula::meta::cpp2::MultiGetResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_multiGet( ::nebula::meta::cpp2::MultiGetResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_multiGet( ::nebula::meta::cpp2::MultiGetResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_multiGet( ::nebula::meta::cpp2::MultiGetResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void multiGetT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::MultiGetReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> multiGetCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void remove(std::unique_ptr callback, const ::nebula::meta::cpp2::RemoveReq& p_req); + virtual void remove(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::RemoveReq& p_req); + protected: + void removeImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::RemoveReq& p_req); + public: + + virtual void sync_remove( ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::RemoveReq& p_req); + virtual void sync_remove(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::RemoveReq& p_req); + + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_remove(const ::nebula::meta::cpp2::RemoveReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_remove(const ::nebula::meta::cpp2::RemoveReq& p_req); + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_remove(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::RemoveReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_remove(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::RemoveReq& p_req); + virtual folly::Future>> header_future_remove(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::RemoveReq& p_req); + virtual folly::SemiFuture>> header_semifuture_remove(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::RemoveReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_remove(const ::nebula::meta::cpp2::RemoveReq& p_req) { + return co_remove(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_remove(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::RemoveReq& p_req) { + return co_remove(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_remove(apache::thrift::RpcOptions* rpcOptions, const ::nebula::meta::cpp2::RemoveReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = removeCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + removeImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + removeImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::meta::cpp2::ExecResp _return; + if (auto ew = recv_wrapped_remove(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void remove(folly::Function callback, const ::nebula::meta::cpp2::RemoveReq& p_req); + + + static folly::exception_wrapper recv_wrapped_remove( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_remove( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_remove( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_remove( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void removeT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::RemoveReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> removeCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void removeRange(std::unique_ptr callback, const ::nebula::meta::cpp2::RemoveRangeReq& p_req); + virtual void removeRange(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::RemoveRangeReq& p_req); + protected: + void removeRangeImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::RemoveRangeReq& p_req); + public: + + virtual void sync_removeRange( ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::RemoveRangeReq& p_req); + virtual void sync_removeRange(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::RemoveRangeReq& p_req); + + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_removeRange(const ::nebula::meta::cpp2::RemoveRangeReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_removeRange(const ::nebula::meta::cpp2::RemoveRangeReq& p_req); + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_removeRange(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::RemoveRangeReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_removeRange(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::RemoveRangeReq& p_req); + virtual folly::Future>> header_future_removeRange(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::RemoveRangeReq& p_req); + virtual folly::SemiFuture>> header_semifuture_removeRange(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::RemoveRangeReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_removeRange(const ::nebula::meta::cpp2::RemoveRangeReq& p_req) { + return co_removeRange(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_removeRange(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::RemoveRangeReq& p_req) { + return co_removeRange(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_removeRange(apache::thrift::RpcOptions* rpcOptions, const ::nebula::meta::cpp2::RemoveRangeReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = removeRangeCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + removeRangeImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + removeRangeImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::meta::cpp2::ExecResp _return; + if (auto ew = recv_wrapped_removeRange(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void removeRange(folly::Function callback, const ::nebula::meta::cpp2::RemoveRangeReq& p_req); + + + static folly::exception_wrapper recv_wrapped_removeRange( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_removeRange( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_removeRange( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_removeRange( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void removeRangeT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::RemoveRangeReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> removeRangeCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void scan(std::unique_ptr callback, const ::nebula::meta::cpp2::ScanReq& p_req); + virtual void scan(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::ScanReq& p_req); + protected: + void scanImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::ScanReq& p_req); + public: + + virtual void sync_scan( ::nebula::meta::cpp2::ScanResp& _return, const ::nebula::meta::cpp2::ScanReq& p_req); + virtual void sync_scan(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ScanResp& _return, const ::nebula::meta::cpp2::ScanReq& p_req); + + virtual folly::Future< ::nebula::meta::cpp2::ScanResp> future_scan(const ::nebula::meta::cpp2::ScanReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ScanResp> semifuture_scan(const ::nebula::meta::cpp2::ScanReq& p_req); + virtual folly::Future< ::nebula::meta::cpp2::ScanResp> future_scan(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ScanReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ScanResp> semifuture_scan(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ScanReq& p_req); + virtual folly::Future>> header_future_scan(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ScanReq& p_req); + virtual folly::SemiFuture>> header_semifuture_scan(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ScanReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::meta::cpp2::ScanResp> co_scan(const ::nebula::meta::cpp2::ScanReq& p_req) { + return co_scan(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::meta::cpp2::ScanResp> co_scan(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ScanReq& p_req) { + return co_scan(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::meta::cpp2::ScanResp> co_scan(apache::thrift::RpcOptions* rpcOptions, const ::nebula::meta::cpp2::ScanReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = scanCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + scanImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + scanImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::meta::cpp2::ScanResp _return; + if (auto ew = recv_wrapped_scan(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void scan(folly::Function callback, const ::nebula::meta::cpp2::ScanReq& p_req); + + + static folly::exception_wrapper recv_wrapped_scan( ::nebula::meta::cpp2::ScanResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_scan( ::nebula::meta::cpp2::ScanResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_scan( ::nebula::meta::cpp2::ScanResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_scan( ::nebula::meta::cpp2::ScanResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void scanT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::ScanReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> scanCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void createTagIndex(std::unique_ptr callback, const ::nebula::meta::cpp2::CreateTagIndexReq& p_req); + virtual void createTagIndex(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::CreateTagIndexReq& p_req); + protected: + void createTagIndexImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::CreateTagIndexReq& p_req); + public: + + virtual void sync_createTagIndex( ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::CreateTagIndexReq& p_req); + virtual void sync_createTagIndex(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::CreateTagIndexReq& p_req); + + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_createTagIndex(const ::nebula::meta::cpp2::CreateTagIndexReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_createTagIndex(const ::nebula::meta::cpp2::CreateTagIndexReq& p_req); + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_createTagIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateTagIndexReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_createTagIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateTagIndexReq& p_req); + virtual folly::Future>> header_future_createTagIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateTagIndexReq& p_req); + virtual folly::SemiFuture>> header_semifuture_createTagIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateTagIndexReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_createTagIndex(const ::nebula::meta::cpp2::CreateTagIndexReq& p_req) { + return co_createTagIndex(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_createTagIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateTagIndexReq& p_req) { + return co_createTagIndex(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_createTagIndex(apache::thrift::RpcOptions* rpcOptions, const ::nebula::meta::cpp2::CreateTagIndexReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = createTagIndexCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + createTagIndexImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + createTagIndexImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::meta::cpp2::ExecResp _return; + if (auto ew = recv_wrapped_createTagIndex(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void createTagIndex(folly::Function callback, const ::nebula::meta::cpp2::CreateTagIndexReq& p_req); + + + static folly::exception_wrapper recv_wrapped_createTagIndex( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_createTagIndex( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_createTagIndex( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_createTagIndex( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void createTagIndexT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::CreateTagIndexReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> createTagIndexCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void dropTagIndex(std::unique_ptr callback, const ::nebula::meta::cpp2::DropTagIndexReq& p_req); + virtual void dropTagIndex(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::DropTagIndexReq& p_req); + protected: + void dropTagIndexImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::DropTagIndexReq& p_req); + public: + + virtual void sync_dropTagIndex( ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::DropTagIndexReq& p_req); + virtual void sync_dropTagIndex(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::DropTagIndexReq& p_req); + + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_dropTagIndex(const ::nebula::meta::cpp2::DropTagIndexReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_dropTagIndex(const ::nebula::meta::cpp2::DropTagIndexReq& p_req); + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_dropTagIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropTagIndexReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_dropTagIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropTagIndexReq& p_req); + virtual folly::Future>> header_future_dropTagIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropTagIndexReq& p_req); + virtual folly::SemiFuture>> header_semifuture_dropTagIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropTagIndexReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_dropTagIndex(const ::nebula::meta::cpp2::DropTagIndexReq& p_req) { + return co_dropTagIndex(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_dropTagIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropTagIndexReq& p_req) { + return co_dropTagIndex(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_dropTagIndex(apache::thrift::RpcOptions* rpcOptions, const ::nebula::meta::cpp2::DropTagIndexReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = dropTagIndexCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + dropTagIndexImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + dropTagIndexImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::meta::cpp2::ExecResp _return; + if (auto ew = recv_wrapped_dropTagIndex(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void dropTagIndex(folly::Function callback, const ::nebula::meta::cpp2::DropTagIndexReq& p_req); + + + static folly::exception_wrapper recv_wrapped_dropTagIndex( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_dropTagIndex( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_dropTagIndex( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_dropTagIndex( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void dropTagIndexT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::DropTagIndexReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> dropTagIndexCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void getTagIndex(std::unique_ptr callback, const ::nebula::meta::cpp2::GetTagIndexReq& p_req); + virtual void getTagIndex(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::GetTagIndexReq& p_req); + protected: + void getTagIndexImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::GetTagIndexReq& p_req); + public: + + virtual void sync_getTagIndex( ::nebula::meta::cpp2::GetTagIndexResp& _return, const ::nebula::meta::cpp2::GetTagIndexReq& p_req); + virtual void sync_getTagIndex(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::GetTagIndexResp& _return, const ::nebula::meta::cpp2::GetTagIndexReq& p_req); + + virtual folly::Future< ::nebula::meta::cpp2::GetTagIndexResp> future_getTagIndex(const ::nebula::meta::cpp2::GetTagIndexReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::GetTagIndexResp> semifuture_getTagIndex(const ::nebula::meta::cpp2::GetTagIndexReq& p_req); + virtual folly::Future< ::nebula::meta::cpp2::GetTagIndexResp> future_getTagIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetTagIndexReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::GetTagIndexResp> semifuture_getTagIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetTagIndexReq& p_req); + virtual folly::Future>> header_future_getTagIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetTagIndexReq& p_req); + virtual folly::SemiFuture>> header_semifuture_getTagIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetTagIndexReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::meta::cpp2::GetTagIndexResp> co_getTagIndex(const ::nebula::meta::cpp2::GetTagIndexReq& p_req) { + return co_getTagIndex(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::meta::cpp2::GetTagIndexResp> co_getTagIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetTagIndexReq& p_req) { + return co_getTagIndex(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::meta::cpp2::GetTagIndexResp> co_getTagIndex(apache::thrift::RpcOptions* rpcOptions, const ::nebula::meta::cpp2::GetTagIndexReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = getTagIndexCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + getTagIndexImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + getTagIndexImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::meta::cpp2::GetTagIndexResp _return; + if (auto ew = recv_wrapped_getTagIndex(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void getTagIndex(folly::Function callback, const ::nebula::meta::cpp2::GetTagIndexReq& p_req); + + + static folly::exception_wrapper recv_wrapped_getTagIndex( ::nebula::meta::cpp2::GetTagIndexResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_getTagIndex( ::nebula::meta::cpp2::GetTagIndexResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_getTagIndex( ::nebula::meta::cpp2::GetTagIndexResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_getTagIndex( ::nebula::meta::cpp2::GetTagIndexResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void getTagIndexT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::GetTagIndexReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> getTagIndexCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void listTagIndexes(std::unique_ptr callback, const ::nebula::meta::cpp2::ListTagIndexesReq& p_req); + virtual void listTagIndexes(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::ListTagIndexesReq& p_req); + protected: + void listTagIndexesImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::ListTagIndexesReq& p_req); + public: + + virtual void sync_listTagIndexes( ::nebula::meta::cpp2::ListTagIndexesResp& _return, const ::nebula::meta::cpp2::ListTagIndexesReq& p_req); + virtual void sync_listTagIndexes(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ListTagIndexesResp& _return, const ::nebula::meta::cpp2::ListTagIndexesReq& p_req); + + virtual folly::Future< ::nebula::meta::cpp2::ListTagIndexesResp> future_listTagIndexes(const ::nebula::meta::cpp2::ListTagIndexesReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ListTagIndexesResp> semifuture_listTagIndexes(const ::nebula::meta::cpp2::ListTagIndexesReq& p_req); + virtual folly::Future< ::nebula::meta::cpp2::ListTagIndexesResp> future_listTagIndexes(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListTagIndexesReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ListTagIndexesResp> semifuture_listTagIndexes(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListTagIndexesReq& p_req); + virtual folly::Future>> header_future_listTagIndexes(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListTagIndexesReq& p_req); + virtual folly::SemiFuture>> header_semifuture_listTagIndexes(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListTagIndexesReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::meta::cpp2::ListTagIndexesResp> co_listTagIndexes(const ::nebula::meta::cpp2::ListTagIndexesReq& p_req) { + return co_listTagIndexes(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::meta::cpp2::ListTagIndexesResp> co_listTagIndexes(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListTagIndexesReq& p_req) { + return co_listTagIndexes(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::meta::cpp2::ListTagIndexesResp> co_listTagIndexes(apache::thrift::RpcOptions* rpcOptions, const ::nebula::meta::cpp2::ListTagIndexesReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = listTagIndexesCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + listTagIndexesImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + listTagIndexesImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::meta::cpp2::ListTagIndexesResp _return; + if (auto ew = recv_wrapped_listTagIndexes(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void listTagIndexes(folly::Function callback, const ::nebula::meta::cpp2::ListTagIndexesReq& p_req); + + + static folly::exception_wrapper recv_wrapped_listTagIndexes( ::nebula::meta::cpp2::ListTagIndexesResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_listTagIndexes( ::nebula::meta::cpp2::ListTagIndexesResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_listTagIndexes( ::nebula::meta::cpp2::ListTagIndexesResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_listTagIndexes( ::nebula::meta::cpp2::ListTagIndexesResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void listTagIndexesT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::ListTagIndexesReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> listTagIndexesCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void rebuildTagIndex(std::unique_ptr callback, const ::nebula::meta::cpp2::RebuildIndexReq& p_req); + virtual void rebuildTagIndex(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::RebuildIndexReq& p_req); + protected: + void rebuildTagIndexImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::RebuildIndexReq& p_req); + public: + + virtual void sync_rebuildTagIndex( ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::RebuildIndexReq& p_req); + virtual void sync_rebuildTagIndex(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::RebuildIndexReq& p_req); + + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_rebuildTagIndex(const ::nebula::meta::cpp2::RebuildIndexReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_rebuildTagIndex(const ::nebula::meta::cpp2::RebuildIndexReq& p_req); + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_rebuildTagIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::RebuildIndexReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_rebuildTagIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::RebuildIndexReq& p_req); + virtual folly::Future>> header_future_rebuildTagIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::RebuildIndexReq& p_req); + virtual folly::SemiFuture>> header_semifuture_rebuildTagIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::RebuildIndexReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_rebuildTagIndex(const ::nebula::meta::cpp2::RebuildIndexReq& p_req) { + return co_rebuildTagIndex(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_rebuildTagIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::RebuildIndexReq& p_req) { + return co_rebuildTagIndex(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_rebuildTagIndex(apache::thrift::RpcOptions* rpcOptions, const ::nebula::meta::cpp2::RebuildIndexReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = rebuildTagIndexCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + rebuildTagIndexImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + rebuildTagIndexImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::meta::cpp2::ExecResp _return; + if (auto ew = recv_wrapped_rebuildTagIndex(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void rebuildTagIndex(folly::Function callback, const ::nebula::meta::cpp2::RebuildIndexReq& p_req); + + + static folly::exception_wrapper recv_wrapped_rebuildTagIndex( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_rebuildTagIndex( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_rebuildTagIndex( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_rebuildTagIndex( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void rebuildTagIndexT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::RebuildIndexReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> rebuildTagIndexCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void listTagIndexStatus(std::unique_ptr callback, const ::nebula::meta::cpp2::ListIndexStatusReq& p_req); + virtual void listTagIndexStatus(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::ListIndexStatusReq& p_req); + protected: + void listTagIndexStatusImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::ListIndexStatusReq& p_req); + public: + + virtual void sync_listTagIndexStatus( ::nebula::meta::cpp2::ListIndexStatusResp& _return, const ::nebula::meta::cpp2::ListIndexStatusReq& p_req); + virtual void sync_listTagIndexStatus(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ListIndexStatusResp& _return, const ::nebula::meta::cpp2::ListIndexStatusReq& p_req); + + virtual folly::Future< ::nebula::meta::cpp2::ListIndexStatusResp> future_listTagIndexStatus(const ::nebula::meta::cpp2::ListIndexStatusReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ListIndexStatusResp> semifuture_listTagIndexStatus(const ::nebula::meta::cpp2::ListIndexStatusReq& p_req); + virtual folly::Future< ::nebula::meta::cpp2::ListIndexStatusResp> future_listTagIndexStatus(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListIndexStatusReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ListIndexStatusResp> semifuture_listTagIndexStatus(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListIndexStatusReq& p_req); + virtual folly::Future>> header_future_listTagIndexStatus(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListIndexStatusReq& p_req); + virtual folly::SemiFuture>> header_semifuture_listTagIndexStatus(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListIndexStatusReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::meta::cpp2::ListIndexStatusResp> co_listTagIndexStatus(const ::nebula::meta::cpp2::ListIndexStatusReq& p_req) { + return co_listTagIndexStatus(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::meta::cpp2::ListIndexStatusResp> co_listTagIndexStatus(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListIndexStatusReq& p_req) { + return co_listTagIndexStatus(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::meta::cpp2::ListIndexStatusResp> co_listTagIndexStatus(apache::thrift::RpcOptions* rpcOptions, const ::nebula::meta::cpp2::ListIndexStatusReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = listTagIndexStatusCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + listTagIndexStatusImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + listTagIndexStatusImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::meta::cpp2::ListIndexStatusResp _return; + if (auto ew = recv_wrapped_listTagIndexStatus(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void listTagIndexStatus(folly::Function callback, const ::nebula::meta::cpp2::ListIndexStatusReq& p_req); + + + static folly::exception_wrapper recv_wrapped_listTagIndexStatus( ::nebula::meta::cpp2::ListIndexStatusResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_listTagIndexStatus( ::nebula::meta::cpp2::ListIndexStatusResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_listTagIndexStatus( ::nebula::meta::cpp2::ListIndexStatusResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_listTagIndexStatus( ::nebula::meta::cpp2::ListIndexStatusResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void listTagIndexStatusT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::ListIndexStatusReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> listTagIndexStatusCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void createEdgeIndex(std::unique_ptr callback, const ::nebula::meta::cpp2::CreateEdgeIndexReq& p_req); + virtual void createEdgeIndex(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::CreateEdgeIndexReq& p_req); + protected: + void createEdgeIndexImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::CreateEdgeIndexReq& p_req); + public: + + virtual void sync_createEdgeIndex( ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::CreateEdgeIndexReq& p_req); + virtual void sync_createEdgeIndex(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::CreateEdgeIndexReq& p_req); + + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_createEdgeIndex(const ::nebula::meta::cpp2::CreateEdgeIndexReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_createEdgeIndex(const ::nebula::meta::cpp2::CreateEdgeIndexReq& p_req); + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_createEdgeIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateEdgeIndexReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_createEdgeIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateEdgeIndexReq& p_req); + virtual folly::Future>> header_future_createEdgeIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateEdgeIndexReq& p_req); + virtual folly::SemiFuture>> header_semifuture_createEdgeIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateEdgeIndexReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_createEdgeIndex(const ::nebula::meta::cpp2::CreateEdgeIndexReq& p_req) { + return co_createEdgeIndex(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_createEdgeIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateEdgeIndexReq& p_req) { + return co_createEdgeIndex(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_createEdgeIndex(apache::thrift::RpcOptions* rpcOptions, const ::nebula::meta::cpp2::CreateEdgeIndexReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = createEdgeIndexCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + createEdgeIndexImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + createEdgeIndexImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::meta::cpp2::ExecResp _return; + if (auto ew = recv_wrapped_createEdgeIndex(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void createEdgeIndex(folly::Function callback, const ::nebula::meta::cpp2::CreateEdgeIndexReq& p_req); + + + static folly::exception_wrapper recv_wrapped_createEdgeIndex( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_createEdgeIndex( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_createEdgeIndex( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_createEdgeIndex( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void createEdgeIndexT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::CreateEdgeIndexReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> createEdgeIndexCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void dropEdgeIndex(std::unique_ptr callback, const ::nebula::meta::cpp2::DropEdgeIndexReq& p_req); + virtual void dropEdgeIndex(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::DropEdgeIndexReq& p_req); + protected: + void dropEdgeIndexImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::DropEdgeIndexReq& p_req); + public: + + virtual void sync_dropEdgeIndex( ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::DropEdgeIndexReq& p_req); + virtual void sync_dropEdgeIndex(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::DropEdgeIndexReq& p_req); + + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_dropEdgeIndex(const ::nebula::meta::cpp2::DropEdgeIndexReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_dropEdgeIndex(const ::nebula::meta::cpp2::DropEdgeIndexReq& p_req); + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_dropEdgeIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropEdgeIndexReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_dropEdgeIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropEdgeIndexReq& p_req); + virtual folly::Future>> header_future_dropEdgeIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropEdgeIndexReq& p_req); + virtual folly::SemiFuture>> header_semifuture_dropEdgeIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropEdgeIndexReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_dropEdgeIndex(const ::nebula::meta::cpp2::DropEdgeIndexReq& p_req) { + return co_dropEdgeIndex(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_dropEdgeIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropEdgeIndexReq& p_req) { + return co_dropEdgeIndex(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_dropEdgeIndex(apache::thrift::RpcOptions* rpcOptions, const ::nebula::meta::cpp2::DropEdgeIndexReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = dropEdgeIndexCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + dropEdgeIndexImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + dropEdgeIndexImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::meta::cpp2::ExecResp _return; + if (auto ew = recv_wrapped_dropEdgeIndex(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void dropEdgeIndex(folly::Function callback, const ::nebula::meta::cpp2::DropEdgeIndexReq& p_req); + + + static folly::exception_wrapper recv_wrapped_dropEdgeIndex( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_dropEdgeIndex( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_dropEdgeIndex( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_dropEdgeIndex( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void dropEdgeIndexT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::DropEdgeIndexReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> dropEdgeIndexCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void getEdgeIndex(std::unique_ptr callback, const ::nebula::meta::cpp2::GetEdgeIndexReq& p_req); + virtual void getEdgeIndex(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::GetEdgeIndexReq& p_req); + protected: + void getEdgeIndexImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::GetEdgeIndexReq& p_req); + public: + + virtual void sync_getEdgeIndex( ::nebula::meta::cpp2::GetEdgeIndexResp& _return, const ::nebula::meta::cpp2::GetEdgeIndexReq& p_req); + virtual void sync_getEdgeIndex(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::GetEdgeIndexResp& _return, const ::nebula::meta::cpp2::GetEdgeIndexReq& p_req); + + virtual folly::Future< ::nebula::meta::cpp2::GetEdgeIndexResp> future_getEdgeIndex(const ::nebula::meta::cpp2::GetEdgeIndexReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::GetEdgeIndexResp> semifuture_getEdgeIndex(const ::nebula::meta::cpp2::GetEdgeIndexReq& p_req); + virtual folly::Future< ::nebula::meta::cpp2::GetEdgeIndexResp> future_getEdgeIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetEdgeIndexReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::GetEdgeIndexResp> semifuture_getEdgeIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetEdgeIndexReq& p_req); + virtual folly::Future>> header_future_getEdgeIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetEdgeIndexReq& p_req); + virtual folly::SemiFuture>> header_semifuture_getEdgeIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetEdgeIndexReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::meta::cpp2::GetEdgeIndexResp> co_getEdgeIndex(const ::nebula::meta::cpp2::GetEdgeIndexReq& p_req) { + return co_getEdgeIndex(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::meta::cpp2::GetEdgeIndexResp> co_getEdgeIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetEdgeIndexReq& p_req) { + return co_getEdgeIndex(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::meta::cpp2::GetEdgeIndexResp> co_getEdgeIndex(apache::thrift::RpcOptions* rpcOptions, const ::nebula::meta::cpp2::GetEdgeIndexReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = getEdgeIndexCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + getEdgeIndexImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + getEdgeIndexImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::meta::cpp2::GetEdgeIndexResp _return; + if (auto ew = recv_wrapped_getEdgeIndex(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void getEdgeIndex(folly::Function callback, const ::nebula::meta::cpp2::GetEdgeIndexReq& p_req); + + + static folly::exception_wrapper recv_wrapped_getEdgeIndex( ::nebula::meta::cpp2::GetEdgeIndexResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_getEdgeIndex( ::nebula::meta::cpp2::GetEdgeIndexResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_getEdgeIndex( ::nebula::meta::cpp2::GetEdgeIndexResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_getEdgeIndex( ::nebula::meta::cpp2::GetEdgeIndexResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void getEdgeIndexT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::GetEdgeIndexReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> getEdgeIndexCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void listEdgeIndexes(std::unique_ptr callback, const ::nebula::meta::cpp2::ListEdgeIndexesReq& p_req); + virtual void listEdgeIndexes(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::ListEdgeIndexesReq& p_req); + protected: + void listEdgeIndexesImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::ListEdgeIndexesReq& p_req); + public: + + virtual void sync_listEdgeIndexes( ::nebula::meta::cpp2::ListEdgeIndexesResp& _return, const ::nebula::meta::cpp2::ListEdgeIndexesReq& p_req); + virtual void sync_listEdgeIndexes(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ListEdgeIndexesResp& _return, const ::nebula::meta::cpp2::ListEdgeIndexesReq& p_req); + + virtual folly::Future< ::nebula::meta::cpp2::ListEdgeIndexesResp> future_listEdgeIndexes(const ::nebula::meta::cpp2::ListEdgeIndexesReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ListEdgeIndexesResp> semifuture_listEdgeIndexes(const ::nebula::meta::cpp2::ListEdgeIndexesReq& p_req); + virtual folly::Future< ::nebula::meta::cpp2::ListEdgeIndexesResp> future_listEdgeIndexes(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListEdgeIndexesReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ListEdgeIndexesResp> semifuture_listEdgeIndexes(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListEdgeIndexesReq& p_req); + virtual folly::Future>> header_future_listEdgeIndexes(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListEdgeIndexesReq& p_req); + virtual folly::SemiFuture>> header_semifuture_listEdgeIndexes(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListEdgeIndexesReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::meta::cpp2::ListEdgeIndexesResp> co_listEdgeIndexes(const ::nebula::meta::cpp2::ListEdgeIndexesReq& p_req) { + return co_listEdgeIndexes(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::meta::cpp2::ListEdgeIndexesResp> co_listEdgeIndexes(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListEdgeIndexesReq& p_req) { + return co_listEdgeIndexes(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::meta::cpp2::ListEdgeIndexesResp> co_listEdgeIndexes(apache::thrift::RpcOptions* rpcOptions, const ::nebula::meta::cpp2::ListEdgeIndexesReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = listEdgeIndexesCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + listEdgeIndexesImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + listEdgeIndexesImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::meta::cpp2::ListEdgeIndexesResp _return; + if (auto ew = recv_wrapped_listEdgeIndexes(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void listEdgeIndexes(folly::Function callback, const ::nebula::meta::cpp2::ListEdgeIndexesReq& p_req); + + + static folly::exception_wrapper recv_wrapped_listEdgeIndexes( ::nebula::meta::cpp2::ListEdgeIndexesResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_listEdgeIndexes( ::nebula::meta::cpp2::ListEdgeIndexesResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_listEdgeIndexes( ::nebula::meta::cpp2::ListEdgeIndexesResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_listEdgeIndexes( ::nebula::meta::cpp2::ListEdgeIndexesResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void listEdgeIndexesT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::ListEdgeIndexesReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> listEdgeIndexesCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void rebuildEdgeIndex(std::unique_ptr callback, const ::nebula::meta::cpp2::RebuildIndexReq& p_req); + virtual void rebuildEdgeIndex(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::RebuildIndexReq& p_req); + protected: + void rebuildEdgeIndexImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::RebuildIndexReq& p_req); + public: + + virtual void sync_rebuildEdgeIndex( ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::RebuildIndexReq& p_req); + virtual void sync_rebuildEdgeIndex(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::RebuildIndexReq& p_req); + + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_rebuildEdgeIndex(const ::nebula::meta::cpp2::RebuildIndexReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_rebuildEdgeIndex(const ::nebula::meta::cpp2::RebuildIndexReq& p_req); + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_rebuildEdgeIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::RebuildIndexReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_rebuildEdgeIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::RebuildIndexReq& p_req); + virtual folly::Future>> header_future_rebuildEdgeIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::RebuildIndexReq& p_req); + virtual folly::SemiFuture>> header_semifuture_rebuildEdgeIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::RebuildIndexReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_rebuildEdgeIndex(const ::nebula::meta::cpp2::RebuildIndexReq& p_req) { + return co_rebuildEdgeIndex(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_rebuildEdgeIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::RebuildIndexReq& p_req) { + return co_rebuildEdgeIndex(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_rebuildEdgeIndex(apache::thrift::RpcOptions* rpcOptions, const ::nebula::meta::cpp2::RebuildIndexReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = rebuildEdgeIndexCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + rebuildEdgeIndexImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + rebuildEdgeIndexImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::meta::cpp2::ExecResp _return; + if (auto ew = recv_wrapped_rebuildEdgeIndex(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void rebuildEdgeIndex(folly::Function callback, const ::nebula::meta::cpp2::RebuildIndexReq& p_req); + + + static folly::exception_wrapper recv_wrapped_rebuildEdgeIndex( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_rebuildEdgeIndex( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_rebuildEdgeIndex( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_rebuildEdgeIndex( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void rebuildEdgeIndexT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::RebuildIndexReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> rebuildEdgeIndexCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void listEdgeIndexStatus(std::unique_ptr callback, const ::nebula::meta::cpp2::ListIndexStatusReq& p_req); + virtual void listEdgeIndexStatus(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::ListIndexStatusReq& p_req); + protected: + void listEdgeIndexStatusImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::ListIndexStatusReq& p_req); + public: + + virtual void sync_listEdgeIndexStatus( ::nebula::meta::cpp2::ListIndexStatusResp& _return, const ::nebula::meta::cpp2::ListIndexStatusReq& p_req); + virtual void sync_listEdgeIndexStatus(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ListIndexStatusResp& _return, const ::nebula::meta::cpp2::ListIndexStatusReq& p_req); + + virtual folly::Future< ::nebula::meta::cpp2::ListIndexStatusResp> future_listEdgeIndexStatus(const ::nebula::meta::cpp2::ListIndexStatusReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ListIndexStatusResp> semifuture_listEdgeIndexStatus(const ::nebula::meta::cpp2::ListIndexStatusReq& p_req); + virtual folly::Future< ::nebula::meta::cpp2::ListIndexStatusResp> future_listEdgeIndexStatus(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListIndexStatusReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ListIndexStatusResp> semifuture_listEdgeIndexStatus(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListIndexStatusReq& p_req); + virtual folly::Future>> header_future_listEdgeIndexStatus(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListIndexStatusReq& p_req); + virtual folly::SemiFuture>> header_semifuture_listEdgeIndexStatus(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListIndexStatusReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::meta::cpp2::ListIndexStatusResp> co_listEdgeIndexStatus(const ::nebula::meta::cpp2::ListIndexStatusReq& p_req) { + return co_listEdgeIndexStatus(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::meta::cpp2::ListIndexStatusResp> co_listEdgeIndexStatus(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListIndexStatusReq& p_req) { + return co_listEdgeIndexStatus(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::meta::cpp2::ListIndexStatusResp> co_listEdgeIndexStatus(apache::thrift::RpcOptions* rpcOptions, const ::nebula::meta::cpp2::ListIndexStatusReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = listEdgeIndexStatusCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + listEdgeIndexStatusImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + listEdgeIndexStatusImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::meta::cpp2::ListIndexStatusResp _return; + if (auto ew = recv_wrapped_listEdgeIndexStatus(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void listEdgeIndexStatus(folly::Function callback, const ::nebula::meta::cpp2::ListIndexStatusReq& p_req); + + + static folly::exception_wrapper recv_wrapped_listEdgeIndexStatus( ::nebula::meta::cpp2::ListIndexStatusResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_listEdgeIndexStatus( ::nebula::meta::cpp2::ListIndexStatusResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_listEdgeIndexStatus( ::nebula::meta::cpp2::ListIndexStatusResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_listEdgeIndexStatus( ::nebula::meta::cpp2::ListIndexStatusResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void listEdgeIndexStatusT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::ListIndexStatusReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> listEdgeIndexStatusCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void createUser(std::unique_ptr callback, const ::nebula::meta::cpp2::CreateUserReq& p_req); + virtual void createUser(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::CreateUserReq& p_req); + protected: + void createUserImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::CreateUserReq& p_req); + public: + + virtual void sync_createUser( ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::CreateUserReq& p_req); + virtual void sync_createUser(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::CreateUserReq& p_req); + + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_createUser(const ::nebula::meta::cpp2::CreateUserReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_createUser(const ::nebula::meta::cpp2::CreateUserReq& p_req); + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_createUser(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateUserReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_createUser(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateUserReq& p_req); + virtual folly::Future>> header_future_createUser(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateUserReq& p_req); + virtual folly::SemiFuture>> header_semifuture_createUser(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateUserReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_createUser(const ::nebula::meta::cpp2::CreateUserReq& p_req) { + return co_createUser(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_createUser(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateUserReq& p_req) { + return co_createUser(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_createUser(apache::thrift::RpcOptions* rpcOptions, const ::nebula::meta::cpp2::CreateUserReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = createUserCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + createUserImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + createUserImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::meta::cpp2::ExecResp _return; + if (auto ew = recv_wrapped_createUser(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void createUser(folly::Function callback, const ::nebula::meta::cpp2::CreateUserReq& p_req); + + + static folly::exception_wrapper recv_wrapped_createUser( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_createUser( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_createUser( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_createUser( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void createUserT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::CreateUserReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> createUserCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void dropUser(std::unique_ptr callback, const ::nebula::meta::cpp2::DropUserReq& p_req); + virtual void dropUser(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::DropUserReq& p_req); + protected: + void dropUserImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::DropUserReq& p_req); + public: + + virtual void sync_dropUser( ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::DropUserReq& p_req); + virtual void sync_dropUser(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::DropUserReq& p_req); + + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_dropUser(const ::nebula::meta::cpp2::DropUserReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_dropUser(const ::nebula::meta::cpp2::DropUserReq& p_req); + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_dropUser(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropUserReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_dropUser(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropUserReq& p_req); + virtual folly::Future>> header_future_dropUser(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropUserReq& p_req); + virtual folly::SemiFuture>> header_semifuture_dropUser(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropUserReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_dropUser(const ::nebula::meta::cpp2::DropUserReq& p_req) { + return co_dropUser(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_dropUser(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropUserReq& p_req) { + return co_dropUser(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_dropUser(apache::thrift::RpcOptions* rpcOptions, const ::nebula::meta::cpp2::DropUserReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = dropUserCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + dropUserImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + dropUserImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::meta::cpp2::ExecResp _return; + if (auto ew = recv_wrapped_dropUser(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void dropUser(folly::Function callback, const ::nebula::meta::cpp2::DropUserReq& p_req); + + + static folly::exception_wrapper recv_wrapped_dropUser( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_dropUser( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_dropUser( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_dropUser( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void dropUserT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::DropUserReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> dropUserCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void alterUser(std::unique_ptr callback, const ::nebula::meta::cpp2::AlterUserReq& p_req); + virtual void alterUser(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::AlterUserReq& p_req); + protected: + void alterUserImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::AlterUserReq& p_req); + public: + + virtual void sync_alterUser( ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::AlterUserReq& p_req); + virtual void sync_alterUser(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::AlterUserReq& p_req); + + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_alterUser(const ::nebula::meta::cpp2::AlterUserReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_alterUser(const ::nebula::meta::cpp2::AlterUserReq& p_req); + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_alterUser(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::AlterUserReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_alterUser(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::AlterUserReq& p_req); + virtual folly::Future>> header_future_alterUser(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::AlterUserReq& p_req); + virtual folly::SemiFuture>> header_semifuture_alterUser(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::AlterUserReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_alterUser(const ::nebula::meta::cpp2::AlterUserReq& p_req) { + return co_alterUser(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_alterUser(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::AlterUserReq& p_req) { + return co_alterUser(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_alterUser(apache::thrift::RpcOptions* rpcOptions, const ::nebula::meta::cpp2::AlterUserReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = alterUserCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + alterUserImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + alterUserImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::meta::cpp2::ExecResp _return; + if (auto ew = recv_wrapped_alterUser(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void alterUser(folly::Function callback, const ::nebula::meta::cpp2::AlterUserReq& p_req); + + + static folly::exception_wrapper recv_wrapped_alterUser( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_alterUser( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_alterUser( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_alterUser( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void alterUserT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::AlterUserReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> alterUserCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void grantRole(std::unique_ptr callback, const ::nebula::meta::cpp2::GrantRoleReq& p_req); + virtual void grantRole(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::GrantRoleReq& p_req); + protected: + void grantRoleImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::GrantRoleReq& p_req); + public: + + virtual void sync_grantRole( ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::GrantRoleReq& p_req); + virtual void sync_grantRole(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::GrantRoleReq& p_req); + + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_grantRole(const ::nebula::meta::cpp2::GrantRoleReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_grantRole(const ::nebula::meta::cpp2::GrantRoleReq& p_req); + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_grantRole(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GrantRoleReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_grantRole(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GrantRoleReq& p_req); + virtual folly::Future>> header_future_grantRole(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GrantRoleReq& p_req); + virtual folly::SemiFuture>> header_semifuture_grantRole(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GrantRoleReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_grantRole(const ::nebula::meta::cpp2::GrantRoleReq& p_req) { + return co_grantRole(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_grantRole(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GrantRoleReq& p_req) { + return co_grantRole(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_grantRole(apache::thrift::RpcOptions* rpcOptions, const ::nebula::meta::cpp2::GrantRoleReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = grantRoleCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + grantRoleImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + grantRoleImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::meta::cpp2::ExecResp _return; + if (auto ew = recv_wrapped_grantRole(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void grantRole(folly::Function callback, const ::nebula::meta::cpp2::GrantRoleReq& p_req); + + + static folly::exception_wrapper recv_wrapped_grantRole( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_grantRole( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_grantRole( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_grantRole( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void grantRoleT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::GrantRoleReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> grantRoleCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void revokeRole(std::unique_ptr callback, const ::nebula::meta::cpp2::RevokeRoleReq& p_req); + virtual void revokeRole(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::RevokeRoleReq& p_req); + protected: + void revokeRoleImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::RevokeRoleReq& p_req); + public: + + virtual void sync_revokeRole( ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::RevokeRoleReq& p_req); + virtual void sync_revokeRole(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::RevokeRoleReq& p_req); + + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_revokeRole(const ::nebula::meta::cpp2::RevokeRoleReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_revokeRole(const ::nebula::meta::cpp2::RevokeRoleReq& p_req); + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_revokeRole(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::RevokeRoleReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_revokeRole(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::RevokeRoleReq& p_req); + virtual folly::Future>> header_future_revokeRole(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::RevokeRoleReq& p_req); + virtual folly::SemiFuture>> header_semifuture_revokeRole(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::RevokeRoleReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_revokeRole(const ::nebula::meta::cpp2::RevokeRoleReq& p_req) { + return co_revokeRole(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_revokeRole(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::RevokeRoleReq& p_req) { + return co_revokeRole(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_revokeRole(apache::thrift::RpcOptions* rpcOptions, const ::nebula::meta::cpp2::RevokeRoleReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = revokeRoleCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + revokeRoleImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + revokeRoleImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::meta::cpp2::ExecResp _return; + if (auto ew = recv_wrapped_revokeRole(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void revokeRole(folly::Function callback, const ::nebula::meta::cpp2::RevokeRoleReq& p_req); + + + static folly::exception_wrapper recv_wrapped_revokeRole( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_revokeRole( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_revokeRole( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_revokeRole( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void revokeRoleT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::RevokeRoleReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> revokeRoleCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void listUsers(std::unique_ptr callback, const ::nebula::meta::cpp2::ListUsersReq& p_req); + virtual void listUsers(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::ListUsersReq& p_req); + protected: + void listUsersImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::ListUsersReq& p_req); + public: + + virtual void sync_listUsers( ::nebula::meta::cpp2::ListUsersResp& _return, const ::nebula::meta::cpp2::ListUsersReq& p_req); + virtual void sync_listUsers(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ListUsersResp& _return, const ::nebula::meta::cpp2::ListUsersReq& p_req); + + virtual folly::Future< ::nebula::meta::cpp2::ListUsersResp> future_listUsers(const ::nebula::meta::cpp2::ListUsersReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ListUsersResp> semifuture_listUsers(const ::nebula::meta::cpp2::ListUsersReq& p_req); + virtual folly::Future< ::nebula::meta::cpp2::ListUsersResp> future_listUsers(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListUsersReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ListUsersResp> semifuture_listUsers(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListUsersReq& p_req); + virtual folly::Future>> header_future_listUsers(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListUsersReq& p_req); + virtual folly::SemiFuture>> header_semifuture_listUsers(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListUsersReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::meta::cpp2::ListUsersResp> co_listUsers(const ::nebula::meta::cpp2::ListUsersReq& p_req) { + return co_listUsers(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::meta::cpp2::ListUsersResp> co_listUsers(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListUsersReq& p_req) { + return co_listUsers(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::meta::cpp2::ListUsersResp> co_listUsers(apache::thrift::RpcOptions* rpcOptions, const ::nebula::meta::cpp2::ListUsersReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = listUsersCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + listUsersImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + listUsersImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::meta::cpp2::ListUsersResp _return; + if (auto ew = recv_wrapped_listUsers(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void listUsers(folly::Function callback, const ::nebula::meta::cpp2::ListUsersReq& p_req); + + + static folly::exception_wrapper recv_wrapped_listUsers( ::nebula::meta::cpp2::ListUsersResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_listUsers( ::nebula::meta::cpp2::ListUsersResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_listUsers( ::nebula::meta::cpp2::ListUsersResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_listUsers( ::nebula::meta::cpp2::ListUsersResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void listUsersT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::ListUsersReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> listUsersCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void listRoles(std::unique_ptr callback, const ::nebula::meta::cpp2::ListRolesReq& p_req); + virtual void listRoles(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::ListRolesReq& p_req); + protected: + void listRolesImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::ListRolesReq& p_req); + public: + + virtual void sync_listRoles( ::nebula::meta::cpp2::ListRolesResp& _return, const ::nebula::meta::cpp2::ListRolesReq& p_req); + virtual void sync_listRoles(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ListRolesResp& _return, const ::nebula::meta::cpp2::ListRolesReq& p_req); + + virtual folly::Future< ::nebula::meta::cpp2::ListRolesResp> future_listRoles(const ::nebula::meta::cpp2::ListRolesReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ListRolesResp> semifuture_listRoles(const ::nebula::meta::cpp2::ListRolesReq& p_req); + virtual folly::Future< ::nebula::meta::cpp2::ListRolesResp> future_listRoles(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListRolesReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ListRolesResp> semifuture_listRoles(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListRolesReq& p_req); + virtual folly::Future>> header_future_listRoles(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListRolesReq& p_req); + virtual folly::SemiFuture>> header_semifuture_listRoles(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListRolesReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::meta::cpp2::ListRolesResp> co_listRoles(const ::nebula::meta::cpp2::ListRolesReq& p_req) { + return co_listRoles(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::meta::cpp2::ListRolesResp> co_listRoles(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListRolesReq& p_req) { + return co_listRoles(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::meta::cpp2::ListRolesResp> co_listRoles(apache::thrift::RpcOptions* rpcOptions, const ::nebula::meta::cpp2::ListRolesReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = listRolesCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + listRolesImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + listRolesImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::meta::cpp2::ListRolesResp _return; + if (auto ew = recv_wrapped_listRoles(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void listRoles(folly::Function callback, const ::nebula::meta::cpp2::ListRolesReq& p_req); + + + static folly::exception_wrapper recv_wrapped_listRoles( ::nebula::meta::cpp2::ListRolesResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_listRoles( ::nebula::meta::cpp2::ListRolesResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_listRoles( ::nebula::meta::cpp2::ListRolesResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_listRoles( ::nebula::meta::cpp2::ListRolesResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void listRolesT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::ListRolesReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> listRolesCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void getUserRoles(std::unique_ptr callback, const ::nebula::meta::cpp2::GetUserRolesReq& p_req); + virtual void getUserRoles(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::GetUserRolesReq& p_req); + protected: + void getUserRolesImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::GetUserRolesReq& p_req); + public: + + virtual void sync_getUserRoles( ::nebula::meta::cpp2::ListRolesResp& _return, const ::nebula::meta::cpp2::GetUserRolesReq& p_req); + virtual void sync_getUserRoles(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ListRolesResp& _return, const ::nebula::meta::cpp2::GetUserRolesReq& p_req); + + virtual folly::Future< ::nebula::meta::cpp2::ListRolesResp> future_getUserRoles(const ::nebula::meta::cpp2::GetUserRolesReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ListRolesResp> semifuture_getUserRoles(const ::nebula::meta::cpp2::GetUserRolesReq& p_req); + virtual folly::Future< ::nebula::meta::cpp2::ListRolesResp> future_getUserRoles(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetUserRolesReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ListRolesResp> semifuture_getUserRoles(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetUserRolesReq& p_req); + virtual folly::Future>> header_future_getUserRoles(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetUserRolesReq& p_req); + virtual folly::SemiFuture>> header_semifuture_getUserRoles(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetUserRolesReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::meta::cpp2::ListRolesResp> co_getUserRoles(const ::nebula::meta::cpp2::GetUserRolesReq& p_req) { + return co_getUserRoles(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::meta::cpp2::ListRolesResp> co_getUserRoles(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetUserRolesReq& p_req) { + return co_getUserRoles(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::meta::cpp2::ListRolesResp> co_getUserRoles(apache::thrift::RpcOptions* rpcOptions, const ::nebula::meta::cpp2::GetUserRolesReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = getUserRolesCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + getUserRolesImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + getUserRolesImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::meta::cpp2::ListRolesResp _return; + if (auto ew = recv_wrapped_getUserRoles(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void getUserRoles(folly::Function callback, const ::nebula::meta::cpp2::GetUserRolesReq& p_req); + + + static folly::exception_wrapper recv_wrapped_getUserRoles( ::nebula::meta::cpp2::ListRolesResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_getUserRoles( ::nebula::meta::cpp2::ListRolesResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_getUserRoles( ::nebula::meta::cpp2::ListRolesResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_getUserRoles( ::nebula::meta::cpp2::ListRolesResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void getUserRolesT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::GetUserRolesReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> getUserRolesCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void changePassword(std::unique_ptr callback, const ::nebula::meta::cpp2::ChangePasswordReq& p_req); + virtual void changePassword(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::ChangePasswordReq& p_req); + protected: + void changePasswordImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::ChangePasswordReq& p_req); + public: + + virtual void sync_changePassword( ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::ChangePasswordReq& p_req); + virtual void sync_changePassword(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::ChangePasswordReq& p_req); + + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_changePassword(const ::nebula::meta::cpp2::ChangePasswordReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_changePassword(const ::nebula::meta::cpp2::ChangePasswordReq& p_req); + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_changePassword(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ChangePasswordReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_changePassword(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ChangePasswordReq& p_req); + virtual folly::Future>> header_future_changePassword(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ChangePasswordReq& p_req); + virtual folly::SemiFuture>> header_semifuture_changePassword(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ChangePasswordReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_changePassword(const ::nebula::meta::cpp2::ChangePasswordReq& p_req) { + return co_changePassword(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_changePassword(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ChangePasswordReq& p_req) { + return co_changePassword(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_changePassword(apache::thrift::RpcOptions* rpcOptions, const ::nebula::meta::cpp2::ChangePasswordReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = changePasswordCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + changePasswordImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + changePasswordImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::meta::cpp2::ExecResp _return; + if (auto ew = recv_wrapped_changePassword(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void changePassword(folly::Function callback, const ::nebula::meta::cpp2::ChangePasswordReq& p_req); + + + static folly::exception_wrapper recv_wrapped_changePassword( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_changePassword( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_changePassword( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_changePassword( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void changePasswordT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::ChangePasswordReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> changePasswordCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void heartBeat(std::unique_ptr callback, const ::nebula::meta::cpp2::HBReq& p_req); + virtual void heartBeat(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::HBReq& p_req); + protected: + void heartBeatImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::HBReq& p_req); + public: + + virtual void sync_heartBeat( ::nebula::meta::cpp2::HBResp& _return, const ::nebula::meta::cpp2::HBReq& p_req); + virtual void sync_heartBeat(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::HBResp& _return, const ::nebula::meta::cpp2::HBReq& p_req); + + virtual folly::Future< ::nebula::meta::cpp2::HBResp> future_heartBeat(const ::nebula::meta::cpp2::HBReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::HBResp> semifuture_heartBeat(const ::nebula::meta::cpp2::HBReq& p_req); + virtual folly::Future< ::nebula::meta::cpp2::HBResp> future_heartBeat(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::HBReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::HBResp> semifuture_heartBeat(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::HBReq& p_req); + virtual folly::Future>> header_future_heartBeat(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::HBReq& p_req); + virtual folly::SemiFuture>> header_semifuture_heartBeat(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::HBReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::meta::cpp2::HBResp> co_heartBeat(const ::nebula::meta::cpp2::HBReq& p_req) { + return co_heartBeat(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::meta::cpp2::HBResp> co_heartBeat(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::HBReq& p_req) { + return co_heartBeat(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::meta::cpp2::HBResp> co_heartBeat(apache::thrift::RpcOptions* rpcOptions, const ::nebula::meta::cpp2::HBReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = heartBeatCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + heartBeatImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + heartBeatImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::meta::cpp2::HBResp _return; + if (auto ew = recv_wrapped_heartBeat(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void heartBeat(folly::Function callback, const ::nebula::meta::cpp2::HBReq& p_req); + + + static folly::exception_wrapper recv_wrapped_heartBeat( ::nebula::meta::cpp2::HBResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_heartBeat( ::nebula::meta::cpp2::HBResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_heartBeat( ::nebula::meta::cpp2::HBResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_heartBeat( ::nebula::meta::cpp2::HBResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void heartBeatT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::HBReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> heartBeatCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void balance(std::unique_ptr callback, const ::nebula::meta::cpp2::BalanceReq& p_req); + virtual void balance(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::BalanceReq& p_req); + protected: + void balanceImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::BalanceReq& p_req); + public: + + virtual void sync_balance( ::nebula::meta::cpp2::BalanceResp& _return, const ::nebula::meta::cpp2::BalanceReq& p_req); + virtual void sync_balance(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::BalanceResp& _return, const ::nebula::meta::cpp2::BalanceReq& p_req); + + virtual folly::Future< ::nebula::meta::cpp2::BalanceResp> future_balance(const ::nebula::meta::cpp2::BalanceReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::BalanceResp> semifuture_balance(const ::nebula::meta::cpp2::BalanceReq& p_req); + virtual folly::Future< ::nebula::meta::cpp2::BalanceResp> future_balance(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::BalanceReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::BalanceResp> semifuture_balance(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::BalanceReq& p_req); + virtual folly::Future>> header_future_balance(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::BalanceReq& p_req); + virtual folly::SemiFuture>> header_semifuture_balance(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::BalanceReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::meta::cpp2::BalanceResp> co_balance(const ::nebula::meta::cpp2::BalanceReq& p_req) { + return co_balance(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::meta::cpp2::BalanceResp> co_balance(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::BalanceReq& p_req) { + return co_balance(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::meta::cpp2::BalanceResp> co_balance(apache::thrift::RpcOptions* rpcOptions, const ::nebula::meta::cpp2::BalanceReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = balanceCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + balanceImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + balanceImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::meta::cpp2::BalanceResp _return; + if (auto ew = recv_wrapped_balance(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void balance(folly::Function callback, const ::nebula::meta::cpp2::BalanceReq& p_req); + + + static folly::exception_wrapper recv_wrapped_balance( ::nebula::meta::cpp2::BalanceResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_balance( ::nebula::meta::cpp2::BalanceResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_balance( ::nebula::meta::cpp2::BalanceResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_balance( ::nebula::meta::cpp2::BalanceResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void balanceT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::BalanceReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> balanceCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void leaderBalance(std::unique_ptr callback, const ::nebula::meta::cpp2::LeaderBalanceReq& p_req); + virtual void leaderBalance(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::LeaderBalanceReq& p_req); + protected: + void leaderBalanceImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::LeaderBalanceReq& p_req); + public: + + virtual void sync_leaderBalance( ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::LeaderBalanceReq& p_req); + virtual void sync_leaderBalance(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::LeaderBalanceReq& p_req); + + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_leaderBalance(const ::nebula::meta::cpp2::LeaderBalanceReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_leaderBalance(const ::nebula::meta::cpp2::LeaderBalanceReq& p_req); + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_leaderBalance(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::LeaderBalanceReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_leaderBalance(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::LeaderBalanceReq& p_req); + virtual folly::Future>> header_future_leaderBalance(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::LeaderBalanceReq& p_req); + virtual folly::SemiFuture>> header_semifuture_leaderBalance(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::LeaderBalanceReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_leaderBalance(const ::nebula::meta::cpp2::LeaderBalanceReq& p_req) { + return co_leaderBalance(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_leaderBalance(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::LeaderBalanceReq& p_req) { + return co_leaderBalance(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_leaderBalance(apache::thrift::RpcOptions* rpcOptions, const ::nebula::meta::cpp2::LeaderBalanceReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = leaderBalanceCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + leaderBalanceImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + leaderBalanceImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::meta::cpp2::ExecResp _return; + if (auto ew = recv_wrapped_leaderBalance(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void leaderBalance(folly::Function callback, const ::nebula::meta::cpp2::LeaderBalanceReq& p_req); + + + static folly::exception_wrapper recv_wrapped_leaderBalance( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_leaderBalance( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_leaderBalance( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_leaderBalance( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void leaderBalanceT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::LeaderBalanceReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> leaderBalanceCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void regConfig(std::unique_ptr callback, const ::nebula::meta::cpp2::RegConfigReq& p_req); + virtual void regConfig(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::RegConfigReq& p_req); + protected: + void regConfigImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::RegConfigReq& p_req); + public: + + virtual void sync_regConfig( ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::RegConfigReq& p_req); + virtual void sync_regConfig(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::RegConfigReq& p_req); + + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_regConfig(const ::nebula::meta::cpp2::RegConfigReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_regConfig(const ::nebula::meta::cpp2::RegConfigReq& p_req); + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_regConfig(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::RegConfigReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_regConfig(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::RegConfigReq& p_req); + virtual folly::Future>> header_future_regConfig(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::RegConfigReq& p_req); + virtual folly::SemiFuture>> header_semifuture_regConfig(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::RegConfigReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_regConfig(const ::nebula::meta::cpp2::RegConfigReq& p_req) { + return co_regConfig(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_regConfig(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::RegConfigReq& p_req) { + return co_regConfig(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_regConfig(apache::thrift::RpcOptions* rpcOptions, const ::nebula::meta::cpp2::RegConfigReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = regConfigCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + regConfigImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + regConfigImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::meta::cpp2::ExecResp _return; + if (auto ew = recv_wrapped_regConfig(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void regConfig(folly::Function callback, const ::nebula::meta::cpp2::RegConfigReq& p_req); + + + static folly::exception_wrapper recv_wrapped_regConfig( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_regConfig( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_regConfig( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_regConfig( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void regConfigT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::RegConfigReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> regConfigCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void getConfig(std::unique_ptr callback, const ::nebula::meta::cpp2::GetConfigReq& p_req); + virtual void getConfig(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::GetConfigReq& p_req); + protected: + void getConfigImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::GetConfigReq& p_req); + public: + + virtual void sync_getConfig( ::nebula::meta::cpp2::GetConfigResp& _return, const ::nebula::meta::cpp2::GetConfigReq& p_req); + virtual void sync_getConfig(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::GetConfigResp& _return, const ::nebula::meta::cpp2::GetConfigReq& p_req); + + virtual folly::Future< ::nebula::meta::cpp2::GetConfigResp> future_getConfig(const ::nebula::meta::cpp2::GetConfigReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::GetConfigResp> semifuture_getConfig(const ::nebula::meta::cpp2::GetConfigReq& p_req); + virtual folly::Future< ::nebula::meta::cpp2::GetConfigResp> future_getConfig(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetConfigReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::GetConfigResp> semifuture_getConfig(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetConfigReq& p_req); + virtual folly::Future>> header_future_getConfig(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetConfigReq& p_req); + virtual folly::SemiFuture>> header_semifuture_getConfig(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetConfigReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::meta::cpp2::GetConfigResp> co_getConfig(const ::nebula::meta::cpp2::GetConfigReq& p_req) { + return co_getConfig(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::meta::cpp2::GetConfigResp> co_getConfig(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetConfigReq& p_req) { + return co_getConfig(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::meta::cpp2::GetConfigResp> co_getConfig(apache::thrift::RpcOptions* rpcOptions, const ::nebula::meta::cpp2::GetConfigReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = getConfigCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + getConfigImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + getConfigImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::meta::cpp2::GetConfigResp _return; + if (auto ew = recv_wrapped_getConfig(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void getConfig(folly::Function callback, const ::nebula::meta::cpp2::GetConfigReq& p_req); + + + static folly::exception_wrapper recv_wrapped_getConfig( ::nebula::meta::cpp2::GetConfigResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_getConfig( ::nebula::meta::cpp2::GetConfigResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_getConfig( ::nebula::meta::cpp2::GetConfigResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_getConfig( ::nebula::meta::cpp2::GetConfigResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void getConfigT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::GetConfigReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> getConfigCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void setConfig(std::unique_ptr callback, const ::nebula::meta::cpp2::SetConfigReq& p_req); + virtual void setConfig(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::SetConfigReq& p_req); + protected: + void setConfigImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::SetConfigReq& p_req); + public: + + virtual void sync_setConfig( ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::SetConfigReq& p_req); + virtual void sync_setConfig(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::SetConfigReq& p_req); + + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_setConfig(const ::nebula::meta::cpp2::SetConfigReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_setConfig(const ::nebula::meta::cpp2::SetConfigReq& p_req); + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_setConfig(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::SetConfigReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_setConfig(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::SetConfigReq& p_req); + virtual folly::Future>> header_future_setConfig(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::SetConfigReq& p_req); + virtual folly::SemiFuture>> header_semifuture_setConfig(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::SetConfigReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_setConfig(const ::nebula::meta::cpp2::SetConfigReq& p_req) { + return co_setConfig(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_setConfig(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::SetConfigReq& p_req) { + return co_setConfig(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_setConfig(apache::thrift::RpcOptions* rpcOptions, const ::nebula::meta::cpp2::SetConfigReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = setConfigCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + setConfigImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + setConfigImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::meta::cpp2::ExecResp _return; + if (auto ew = recv_wrapped_setConfig(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void setConfig(folly::Function callback, const ::nebula::meta::cpp2::SetConfigReq& p_req); + + + static folly::exception_wrapper recv_wrapped_setConfig( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_setConfig( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_setConfig( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_setConfig( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void setConfigT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::SetConfigReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> setConfigCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void listConfigs(std::unique_ptr callback, const ::nebula::meta::cpp2::ListConfigsReq& p_req); + virtual void listConfigs(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::ListConfigsReq& p_req); + protected: + void listConfigsImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::ListConfigsReq& p_req); + public: + + virtual void sync_listConfigs( ::nebula::meta::cpp2::ListConfigsResp& _return, const ::nebula::meta::cpp2::ListConfigsReq& p_req); + virtual void sync_listConfigs(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ListConfigsResp& _return, const ::nebula::meta::cpp2::ListConfigsReq& p_req); + + virtual folly::Future< ::nebula::meta::cpp2::ListConfigsResp> future_listConfigs(const ::nebula::meta::cpp2::ListConfigsReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ListConfigsResp> semifuture_listConfigs(const ::nebula::meta::cpp2::ListConfigsReq& p_req); + virtual folly::Future< ::nebula::meta::cpp2::ListConfigsResp> future_listConfigs(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListConfigsReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ListConfigsResp> semifuture_listConfigs(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListConfigsReq& p_req); + virtual folly::Future>> header_future_listConfigs(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListConfigsReq& p_req); + virtual folly::SemiFuture>> header_semifuture_listConfigs(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListConfigsReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::meta::cpp2::ListConfigsResp> co_listConfigs(const ::nebula::meta::cpp2::ListConfigsReq& p_req) { + return co_listConfigs(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::meta::cpp2::ListConfigsResp> co_listConfigs(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListConfigsReq& p_req) { + return co_listConfigs(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::meta::cpp2::ListConfigsResp> co_listConfigs(apache::thrift::RpcOptions* rpcOptions, const ::nebula::meta::cpp2::ListConfigsReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = listConfigsCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + listConfigsImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + listConfigsImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::meta::cpp2::ListConfigsResp _return; + if (auto ew = recv_wrapped_listConfigs(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void listConfigs(folly::Function callback, const ::nebula::meta::cpp2::ListConfigsReq& p_req); + + + static folly::exception_wrapper recv_wrapped_listConfigs( ::nebula::meta::cpp2::ListConfigsResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_listConfigs( ::nebula::meta::cpp2::ListConfigsResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_listConfigs( ::nebula::meta::cpp2::ListConfigsResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_listConfigs( ::nebula::meta::cpp2::ListConfigsResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void listConfigsT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::ListConfigsReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> listConfigsCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void createSnapshot(std::unique_ptr callback, const ::nebula::meta::cpp2::CreateSnapshotReq& p_req); + virtual void createSnapshot(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::CreateSnapshotReq& p_req); + protected: + void createSnapshotImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::CreateSnapshotReq& p_req); + public: + + virtual void sync_createSnapshot( ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::CreateSnapshotReq& p_req); + virtual void sync_createSnapshot(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::CreateSnapshotReq& p_req); + + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_createSnapshot(const ::nebula::meta::cpp2::CreateSnapshotReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_createSnapshot(const ::nebula::meta::cpp2::CreateSnapshotReq& p_req); + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_createSnapshot(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateSnapshotReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_createSnapshot(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateSnapshotReq& p_req); + virtual folly::Future>> header_future_createSnapshot(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateSnapshotReq& p_req); + virtual folly::SemiFuture>> header_semifuture_createSnapshot(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateSnapshotReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_createSnapshot(const ::nebula::meta::cpp2::CreateSnapshotReq& p_req) { + return co_createSnapshot(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_createSnapshot(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateSnapshotReq& p_req) { + return co_createSnapshot(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_createSnapshot(apache::thrift::RpcOptions* rpcOptions, const ::nebula::meta::cpp2::CreateSnapshotReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = createSnapshotCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + createSnapshotImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + createSnapshotImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::meta::cpp2::ExecResp _return; + if (auto ew = recv_wrapped_createSnapshot(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void createSnapshot(folly::Function callback, const ::nebula::meta::cpp2::CreateSnapshotReq& p_req); + + + static folly::exception_wrapper recv_wrapped_createSnapshot( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_createSnapshot( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_createSnapshot( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_createSnapshot( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void createSnapshotT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::CreateSnapshotReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> createSnapshotCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void dropSnapshot(std::unique_ptr callback, const ::nebula::meta::cpp2::DropSnapshotReq& p_req); + virtual void dropSnapshot(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::DropSnapshotReq& p_req); + protected: + void dropSnapshotImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::DropSnapshotReq& p_req); + public: + + virtual void sync_dropSnapshot( ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::DropSnapshotReq& p_req); + virtual void sync_dropSnapshot(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::DropSnapshotReq& p_req); + + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_dropSnapshot(const ::nebula::meta::cpp2::DropSnapshotReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_dropSnapshot(const ::nebula::meta::cpp2::DropSnapshotReq& p_req); + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_dropSnapshot(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropSnapshotReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_dropSnapshot(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropSnapshotReq& p_req); + virtual folly::Future>> header_future_dropSnapshot(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropSnapshotReq& p_req); + virtual folly::SemiFuture>> header_semifuture_dropSnapshot(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropSnapshotReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_dropSnapshot(const ::nebula::meta::cpp2::DropSnapshotReq& p_req) { + return co_dropSnapshot(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_dropSnapshot(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropSnapshotReq& p_req) { + return co_dropSnapshot(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_dropSnapshot(apache::thrift::RpcOptions* rpcOptions, const ::nebula::meta::cpp2::DropSnapshotReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = dropSnapshotCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + dropSnapshotImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + dropSnapshotImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::meta::cpp2::ExecResp _return; + if (auto ew = recv_wrapped_dropSnapshot(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void dropSnapshot(folly::Function callback, const ::nebula::meta::cpp2::DropSnapshotReq& p_req); + + + static folly::exception_wrapper recv_wrapped_dropSnapshot( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_dropSnapshot( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_dropSnapshot( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_dropSnapshot( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void dropSnapshotT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::DropSnapshotReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> dropSnapshotCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void listSnapshots(std::unique_ptr callback, const ::nebula::meta::cpp2::ListSnapshotsReq& p_req); + virtual void listSnapshots(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::ListSnapshotsReq& p_req); + protected: + void listSnapshotsImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::ListSnapshotsReq& p_req); + public: + + virtual void sync_listSnapshots( ::nebula::meta::cpp2::ListSnapshotsResp& _return, const ::nebula::meta::cpp2::ListSnapshotsReq& p_req); + virtual void sync_listSnapshots(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ListSnapshotsResp& _return, const ::nebula::meta::cpp2::ListSnapshotsReq& p_req); + + virtual folly::Future< ::nebula::meta::cpp2::ListSnapshotsResp> future_listSnapshots(const ::nebula::meta::cpp2::ListSnapshotsReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ListSnapshotsResp> semifuture_listSnapshots(const ::nebula::meta::cpp2::ListSnapshotsReq& p_req); + virtual folly::Future< ::nebula::meta::cpp2::ListSnapshotsResp> future_listSnapshots(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListSnapshotsReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ListSnapshotsResp> semifuture_listSnapshots(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListSnapshotsReq& p_req); + virtual folly::Future>> header_future_listSnapshots(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListSnapshotsReq& p_req); + virtual folly::SemiFuture>> header_semifuture_listSnapshots(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListSnapshotsReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::meta::cpp2::ListSnapshotsResp> co_listSnapshots(const ::nebula::meta::cpp2::ListSnapshotsReq& p_req) { + return co_listSnapshots(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::meta::cpp2::ListSnapshotsResp> co_listSnapshots(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListSnapshotsReq& p_req) { + return co_listSnapshots(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::meta::cpp2::ListSnapshotsResp> co_listSnapshots(apache::thrift::RpcOptions* rpcOptions, const ::nebula::meta::cpp2::ListSnapshotsReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = listSnapshotsCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + listSnapshotsImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + listSnapshotsImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::meta::cpp2::ListSnapshotsResp _return; + if (auto ew = recv_wrapped_listSnapshots(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void listSnapshots(folly::Function callback, const ::nebula::meta::cpp2::ListSnapshotsReq& p_req); + + + static folly::exception_wrapper recv_wrapped_listSnapshots( ::nebula::meta::cpp2::ListSnapshotsResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_listSnapshots( ::nebula::meta::cpp2::ListSnapshotsResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_listSnapshots( ::nebula::meta::cpp2::ListSnapshotsResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_listSnapshots( ::nebula::meta::cpp2::ListSnapshotsResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void listSnapshotsT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::ListSnapshotsReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> listSnapshotsCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void runAdminJob(std::unique_ptr callback, const ::nebula::meta::cpp2::AdminJobReq& p_req); + virtual void runAdminJob(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::AdminJobReq& p_req); + protected: + void runAdminJobImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::AdminJobReq& p_req); + public: + + virtual void sync_runAdminJob( ::nebula::meta::cpp2::AdminJobResp& _return, const ::nebula::meta::cpp2::AdminJobReq& p_req); + virtual void sync_runAdminJob(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::AdminJobResp& _return, const ::nebula::meta::cpp2::AdminJobReq& p_req); + + virtual folly::Future< ::nebula::meta::cpp2::AdminJobResp> future_runAdminJob(const ::nebula::meta::cpp2::AdminJobReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::AdminJobResp> semifuture_runAdminJob(const ::nebula::meta::cpp2::AdminJobReq& p_req); + virtual folly::Future< ::nebula::meta::cpp2::AdminJobResp> future_runAdminJob(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::AdminJobReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::AdminJobResp> semifuture_runAdminJob(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::AdminJobReq& p_req); + virtual folly::Future>> header_future_runAdminJob(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::AdminJobReq& p_req); + virtual folly::SemiFuture>> header_semifuture_runAdminJob(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::AdminJobReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::meta::cpp2::AdminJobResp> co_runAdminJob(const ::nebula::meta::cpp2::AdminJobReq& p_req) { + return co_runAdminJob(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::meta::cpp2::AdminJobResp> co_runAdminJob(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::AdminJobReq& p_req) { + return co_runAdminJob(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::meta::cpp2::AdminJobResp> co_runAdminJob(apache::thrift::RpcOptions* rpcOptions, const ::nebula::meta::cpp2::AdminJobReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = runAdminJobCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + runAdminJobImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + runAdminJobImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::meta::cpp2::AdminJobResp _return; + if (auto ew = recv_wrapped_runAdminJob(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void runAdminJob(folly::Function callback, const ::nebula::meta::cpp2::AdminJobReq& p_req); + + + static folly::exception_wrapper recv_wrapped_runAdminJob( ::nebula::meta::cpp2::AdminJobResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_runAdminJob( ::nebula::meta::cpp2::AdminJobResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_runAdminJob( ::nebula::meta::cpp2::AdminJobResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_runAdminJob( ::nebula::meta::cpp2::AdminJobResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void runAdminJobT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::AdminJobReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> runAdminJobCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void addZone(std::unique_ptr callback, const ::nebula::meta::cpp2::AddZoneReq& p_req); + virtual void addZone(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::AddZoneReq& p_req); + protected: + void addZoneImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::AddZoneReq& p_req); + public: + + virtual void sync_addZone( ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::AddZoneReq& p_req); + virtual void sync_addZone(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::AddZoneReq& p_req); + + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_addZone(const ::nebula::meta::cpp2::AddZoneReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_addZone(const ::nebula::meta::cpp2::AddZoneReq& p_req); + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_addZone(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::AddZoneReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_addZone(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::AddZoneReq& p_req); + virtual folly::Future>> header_future_addZone(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::AddZoneReq& p_req); + virtual folly::SemiFuture>> header_semifuture_addZone(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::AddZoneReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_addZone(const ::nebula::meta::cpp2::AddZoneReq& p_req) { + return co_addZone(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_addZone(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::AddZoneReq& p_req) { + return co_addZone(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_addZone(apache::thrift::RpcOptions* rpcOptions, const ::nebula::meta::cpp2::AddZoneReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = addZoneCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + addZoneImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + addZoneImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::meta::cpp2::ExecResp _return; + if (auto ew = recv_wrapped_addZone(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void addZone(folly::Function callback, const ::nebula::meta::cpp2::AddZoneReq& p_req); + + + static folly::exception_wrapper recv_wrapped_addZone( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_addZone( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_addZone( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_addZone( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void addZoneT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::AddZoneReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> addZoneCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void dropZone(std::unique_ptr callback, const ::nebula::meta::cpp2::DropZoneReq& p_req); + virtual void dropZone(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::DropZoneReq& p_req); + protected: + void dropZoneImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::DropZoneReq& p_req); + public: + + virtual void sync_dropZone( ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::DropZoneReq& p_req); + virtual void sync_dropZone(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::DropZoneReq& p_req); + + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_dropZone(const ::nebula::meta::cpp2::DropZoneReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_dropZone(const ::nebula::meta::cpp2::DropZoneReq& p_req); + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_dropZone(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropZoneReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_dropZone(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropZoneReq& p_req); + virtual folly::Future>> header_future_dropZone(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropZoneReq& p_req); + virtual folly::SemiFuture>> header_semifuture_dropZone(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropZoneReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_dropZone(const ::nebula::meta::cpp2::DropZoneReq& p_req) { + return co_dropZone(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_dropZone(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropZoneReq& p_req) { + return co_dropZone(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_dropZone(apache::thrift::RpcOptions* rpcOptions, const ::nebula::meta::cpp2::DropZoneReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = dropZoneCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + dropZoneImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + dropZoneImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::meta::cpp2::ExecResp _return; + if (auto ew = recv_wrapped_dropZone(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void dropZone(folly::Function callback, const ::nebula::meta::cpp2::DropZoneReq& p_req); + + + static folly::exception_wrapper recv_wrapped_dropZone( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_dropZone( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_dropZone( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_dropZone( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void dropZoneT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::DropZoneReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> dropZoneCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void addHostIntoZone(std::unique_ptr callback, const ::nebula::meta::cpp2::AddHostIntoZoneReq& p_req); + virtual void addHostIntoZone(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::AddHostIntoZoneReq& p_req); + protected: + void addHostIntoZoneImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::AddHostIntoZoneReq& p_req); + public: + + virtual void sync_addHostIntoZone( ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::AddHostIntoZoneReq& p_req); + virtual void sync_addHostIntoZone(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::AddHostIntoZoneReq& p_req); + + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_addHostIntoZone(const ::nebula::meta::cpp2::AddHostIntoZoneReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_addHostIntoZone(const ::nebula::meta::cpp2::AddHostIntoZoneReq& p_req); + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_addHostIntoZone(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::AddHostIntoZoneReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_addHostIntoZone(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::AddHostIntoZoneReq& p_req); + virtual folly::Future>> header_future_addHostIntoZone(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::AddHostIntoZoneReq& p_req); + virtual folly::SemiFuture>> header_semifuture_addHostIntoZone(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::AddHostIntoZoneReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_addHostIntoZone(const ::nebula::meta::cpp2::AddHostIntoZoneReq& p_req) { + return co_addHostIntoZone(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_addHostIntoZone(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::AddHostIntoZoneReq& p_req) { + return co_addHostIntoZone(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_addHostIntoZone(apache::thrift::RpcOptions* rpcOptions, const ::nebula::meta::cpp2::AddHostIntoZoneReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = addHostIntoZoneCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + addHostIntoZoneImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + addHostIntoZoneImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::meta::cpp2::ExecResp _return; + if (auto ew = recv_wrapped_addHostIntoZone(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void addHostIntoZone(folly::Function callback, const ::nebula::meta::cpp2::AddHostIntoZoneReq& p_req); + + + static folly::exception_wrapper recv_wrapped_addHostIntoZone( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_addHostIntoZone( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_addHostIntoZone( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_addHostIntoZone( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void addHostIntoZoneT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::AddHostIntoZoneReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> addHostIntoZoneCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void dropHostFromZone(std::unique_ptr callback, const ::nebula::meta::cpp2::DropHostFromZoneReq& p_req); + virtual void dropHostFromZone(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::DropHostFromZoneReq& p_req); + protected: + void dropHostFromZoneImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::DropHostFromZoneReq& p_req); + public: + + virtual void sync_dropHostFromZone( ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::DropHostFromZoneReq& p_req); + virtual void sync_dropHostFromZone(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::DropHostFromZoneReq& p_req); + + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_dropHostFromZone(const ::nebula::meta::cpp2::DropHostFromZoneReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_dropHostFromZone(const ::nebula::meta::cpp2::DropHostFromZoneReq& p_req); + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_dropHostFromZone(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropHostFromZoneReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_dropHostFromZone(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropHostFromZoneReq& p_req); + virtual folly::Future>> header_future_dropHostFromZone(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropHostFromZoneReq& p_req); + virtual folly::SemiFuture>> header_semifuture_dropHostFromZone(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropHostFromZoneReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_dropHostFromZone(const ::nebula::meta::cpp2::DropHostFromZoneReq& p_req) { + return co_dropHostFromZone(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_dropHostFromZone(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropHostFromZoneReq& p_req) { + return co_dropHostFromZone(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_dropHostFromZone(apache::thrift::RpcOptions* rpcOptions, const ::nebula::meta::cpp2::DropHostFromZoneReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = dropHostFromZoneCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + dropHostFromZoneImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + dropHostFromZoneImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::meta::cpp2::ExecResp _return; + if (auto ew = recv_wrapped_dropHostFromZone(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void dropHostFromZone(folly::Function callback, const ::nebula::meta::cpp2::DropHostFromZoneReq& p_req); + + + static folly::exception_wrapper recv_wrapped_dropHostFromZone( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_dropHostFromZone( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_dropHostFromZone( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_dropHostFromZone( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void dropHostFromZoneT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::DropHostFromZoneReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> dropHostFromZoneCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void getZone(std::unique_ptr callback, const ::nebula::meta::cpp2::GetZoneReq& p_req); + virtual void getZone(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::GetZoneReq& p_req); + protected: + void getZoneImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::GetZoneReq& p_req); + public: + + virtual void sync_getZone( ::nebula::meta::cpp2::GetZoneResp& _return, const ::nebula::meta::cpp2::GetZoneReq& p_req); + virtual void sync_getZone(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::GetZoneResp& _return, const ::nebula::meta::cpp2::GetZoneReq& p_req); + + virtual folly::Future< ::nebula::meta::cpp2::GetZoneResp> future_getZone(const ::nebula::meta::cpp2::GetZoneReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::GetZoneResp> semifuture_getZone(const ::nebula::meta::cpp2::GetZoneReq& p_req); + virtual folly::Future< ::nebula::meta::cpp2::GetZoneResp> future_getZone(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetZoneReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::GetZoneResp> semifuture_getZone(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetZoneReq& p_req); + virtual folly::Future>> header_future_getZone(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetZoneReq& p_req); + virtual folly::SemiFuture>> header_semifuture_getZone(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetZoneReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::meta::cpp2::GetZoneResp> co_getZone(const ::nebula::meta::cpp2::GetZoneReq& p_req) { + return co_getZone(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::meta::cpp2::GetZoneResp> co_getZone(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetZoneReq& p_req) { + return co_getZone(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::meta::cpp2::GetZoneResp> co_getZone(apache::thrift::RpcOptions* rpcOptions, const ::nebula::meta::cpp2::GetZoneReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = getZoneCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + getZoneImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + getZoneImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::meta::cpp2::GetZoneResp _return; + if (auto ew = recv_wrapped_getZone(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void getZone(folly::Function callback, const ::nebula::meta::cpp2::GetZoneReq& p_req); + + + static folly::exception_wrapper recv_wrapped_getZone( ::nebula::meta::cpp2::GetZoneResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_getZone( ::nebula::meta::cpp2::GetZoneResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_getZone( ::nebula::meta::cpp2::GetZoneResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_getZone( ::nebula::meta::cpp2::GetZoneResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void getZoneT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::GetZoneReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> getZoneCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void listZones(std::unique_ptr callback, const ::nebula::meta::cpp2::ListZonesReq& p_req); + virtual void listZones(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::ListZonesReq& p_req); + protected: + void listZonesImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::ListZonesReq& p_req); + public: + + virtual void sync_listZones( ::nebula::meta::cpp2::ListZonesResp& _return, const ::nebula::meta::cpp2::ListZonesReq& p_req); + virtual void sync_listZones(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ListZonesResp& _return, const ::nebula::meta::cpp2::ListZonesReq& p_req); + + virtual folly::Future< ::nebula::meta::cpp2::ListZonesResp> future_listZones(const ::nebula::meta::cpp2::ListZonesReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ListZonesResp> semifuture_listZones(const ::nebula::meta::cpp2::ListZonesReq& p_req); + virtual folly::Future< ::nebula::meta::cpp2::ListZonesResp> future_listZones(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListZonesReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ListZonesResp> semifuture_listZones(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListZonesReq& p_req); + virtual folly::Future>> header_future_listZones(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListZonesReq& p_req); + virtual folly::SemiFuture>> header_semifuture_listZones(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListZonesReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::meta::cpp2::ListZonesResp> co_listZones(const ::nebula::meta::cpp2::ListZonesReq& p_req) { + return co_listZones(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::meta::cpp2::ListZonesResp> co_listZones(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListZonesReq& p_req) { + return co_listZones(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::meta::cpp2::ListZonesResp> co_listZones(apache::thrift::RpcOptions* rpcOptions, const ::nebula::meta::cpp2::ListZonesReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = listZonesCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + listZonesImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + listZonesImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::meta::cpp2::ListZonesResp _return; + if (auto ew = recv_wrapped_listZones(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void listZones(folly::Function callback, const ::nebula::meta::cpp2::ListZonesReq& p_req); + + + static folly::exception_wrapper recv_wrapped_listZones( ::nebula::meta::cpp2::ListZonesResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_listZones( ::nebula::meta::cpp2::ListZonesResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_listZones( ::nebula::meta::cpp2::ListZonesResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_listZones( ::nebula::meta::cpp2::ListZonesResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void listZonesT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::ListZonesReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> listZonesCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void addGroup(std::unique_ptr callback, const ::nebula::meta::cpp2::AddGroupReq& p_req); + virtual void addGroup(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::AddGroupReq& p_req); + protected: + void addGroupImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::AddGroupReq& p_req); + public: + + virtual void sync_addGroup( ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::AddGroupReq& p_req); + virtual void sync_addGroup(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::AddGroupReq& p_req); + + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_addGroup(const ::nebula::meta::cpp2::AddGroupReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_addGroup(const ::nebula::meta::cpp2::AddGroupReq& p_req); + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_addGroup(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::AddGroupReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_addGroup(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::AddGroupReq& p_req); + virtual folly::Future>> header_future_addGroup(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::AddGroupReq& p_req); + virtual folly::SemiFuture>> header_semifuture_addGroup(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::AddGroupReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_addGroup(const ::nebula::meta::cpp2::AddGroupReq& p_req) { + return co_addGroup(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_addGroup(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::AddGroupReq& p_req) { + return co_addGroup(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_addGroup(apache::thrift::RpcOptions* rpcOptions, const ::nebula::meta::cpp2::AddGroupReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = addGroupCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + addGroupImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + addGroupImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::meta::cpp2::ExecResp _return; + if (auto ew = recv_wrapped_addGroup(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void addGroup(folly::Function callback, const ::nebula::meta::cpp2::AddGroupReq& p_req); + + + static folly::exception_wrapper recv_wrapped_addGroup( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_addGroup( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_addGroup( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_addGroup( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void addGroupT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::AddGroupReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> addGroupCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void dropGroup(std::unique_ptr callback, const ::nebula::meta::cpp2::DropGroupReq& p_req); + virtual void dropGroup(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::DropGroupReq& p_req); + protected: + void dropGroupImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::DropGroupReq& p_req); + public: + + virtual void sync_dropGroup( ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::DropGroupReq& p_req); + virtual void sync_dropGroup(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::DropGroupReq& p_req); + + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_dropGroup(const ::nebula::meta::cpp2::DropGroupReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_dropGroup(const ::nebula::meta::cpp2::DropGroupReq& p_req); + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_dropGroup(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropGroupReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_dropGroup(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropGroupReq& p_req); + virtual folly::Future>> header_future_dropGroup(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropGroupReq& p_req); + virtual folly::SemiFuture>> header_semifuture_dropGroup(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropGroupReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_dropGroup(const ::nebula::meta::cpp2::DropGroupReq& p_req) { + return co_dropGroup(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_dropGroup(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropGroupReq& p_req) { + return co_dropGroup(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_dropGroup(apache::thrift::RpcOptions* rpcOptions, const ::nebula::meta::cpp2::DropGroupReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = dropGroupCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + dropGroupImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + dropGroupImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::meta::cpp2::ExecResp _return; + if (auto ew = recv_wrapped_dropGroup(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void dropGroup(folly::Function callback, const ::nebula::meta::cpp2::DropGroupReq& p_req); + + + static folly::exception_wrapper recv_wrapped_dropGroup( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_dropGroup( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_dropGroup( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_dropGroup( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void dropGroupT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::DropGroupReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> dropGroupCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void addZoneIntoGroup(std::unique_ptr callback, const ::nebula::meta::cpp2::AddZoneIntoGroupReq& p_req); + virtual void addZoneIntoGroup(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::AddZoneIntoGroupReq& p_req); + protected: + void addZoneIntoGroupImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::AddZoneIntoGroupReq& p_req); + public: + + virtual void sync_addZoneIntoGroup( ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::AddZoneIntoGroupReq& p_req); + virtual void sync_addZoneIntoGroup(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::AddZoneIntoGroupReq& p_req); + + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_addZoneIntoGroup(const ::nebula::meta::cpp2::AddZoneIntoGroupReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_addZoneIntoGroup(const ::nebula::meta::cpp2::AddZoneIntoGroupReq& p_req); + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_addZoneIntoGroup(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::AddZoneIntoGroupReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_addZoneIntoGroup(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::AddZoneIntoGroupReq& p_req); + virtual folly::Future>> header_future_addZoneIntoGroup(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::AddZoneIntoGroupReq& p_req); + virtual folly::SemiFuture>> header_semifuture_addZoneIntoGroup(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::AddZoneIntoGroupReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_addZoneIntoGroup(const ::nebula::meta::cpp2::AddZoneIntoGroupReq& p_req) { + return co_addZoneIntoGroup(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_addZoneIntoGroup(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::AddZoneIntoGroupReq& p_req) { + return co_addZoneIntoGroup(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_addZoneIntoGroup(apache::thrift::RpcOptions* rpcOptions, const ::nebula::meta::cpp2::AddZoneIntoGroupReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = addZoneIntoGroupCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + addZoneIntoGroupImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + addZoneIntoGroupImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::meta::cpp2::ExecResp _return; + if (auto ew = recv_wrapped_addZoneIntoGroup(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void addZoneIntoGroup(folly::Function callback, const ::nebula::meta::cpp2::AddZoneIntoGroupReq& p_req); + + + static folly::exception_wrapper recv_wrapped_addZoneIntoGroup( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_addZoneIntoGroup( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_addZoneIntoGroup( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_addZoneIntoGroup( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void addZoneIntoGroupT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::AddZoneIntoGroupReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> addZoneIntoGroupCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void dropZoneFromGroup(std::unique_ptr callback, const ::nebula::meta::cpp2::DropZoneFromGroupReq& p_req); + virtual void dropZoneFromGroup(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::DropZoneFromGroupReq& p_req); + protected: + void dropZoneFromGroupImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::DropZoneFromGroupReq& p_req); + public: + + virtual void sync_dropZoneFromGroup( ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::DropZoneFromGroupReq& p_req); + virtual void sync_dropZoneFromGroup(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::DropZoneFromGroupReq& p_req); + + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_dropZoneFromGroup(const ::nebula::meta::cpp2::DropZoneFromGroupReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_dropZoneFromGroup(const ::nebula::meta::cpp2::DropZoneFromGroupReq& p_req); + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_dropZoneFromGroup(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropZoneFromGroupReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_dropZoneFromGroup(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropZoneFromGroupReq& p_req); + virtual folly::Future>> header_future_dropZoneFromGroup(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropZoneFromGroupReq& p_req); + virtual folly::SemiFuture>> header_semifuture_dropZoneFromGroup(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropZoneFromGroupReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_dropZoneFromGroup(const ::nebula::meta::cpp2::DropZoneFromGroupReq& p_req) { + return co_dropZoneFromGroup(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_dropZoneFromGroup(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropZoneFromGroupReq& p_req) { + return co_dropZoneFromGroup(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_dropZoneFromGroup(apache::thrift::RpcOptions* rpcOptions, const ::nebula::meta::cpp2::DropZoneFromGroupReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = dropZoneFromGroupCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + dropZoneFromGroupImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + dropZoneFromGroupImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::meta::cpp2::ExecResp _return; + if (auto ew = recv_wrapped_dropZoneFromGroup(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void dropZoneFromGroup(folly::Function callback, const ::nebula::meta::cpp2::DropZoneFromGroupReq& p_req); + + + static folly::exception_wrapper recv_wrapped_dropZoneFromGroup( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_dropZoneFromGroup( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_dropZoneFromGroup( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_dropZoneFromGroup( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void dropZoneFromGroupT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::DropZoneFromGroupReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> dropZoneFromGroupCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void getGroup(std::unique_ptr callback, const ::nebula::meta::cpp2::GetGroupReq& p_req); + virtual void getGroup(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::GetGroupReq& p_req); + protected: + void getGroupImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::GetGroupReq& p_req); + public: + + virtual void sync_getGroup( ::nebula::meta::cpp2::GetGroupResp& _return, const ::nebula::meta::cpp2::GetGroupReq& p_req); + virtual void sync_getGroup(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::GetGroupResp& _return, const ::nebula::meta::cpp2::GetGroupReq& p_req); + + virtual folly::Future< ::nebula::meta::cpp2::GetGroupResp> future_getGroup(const ::nebula::meta::cpp2::GetGroupReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::GetGroupResp> semifuture_getGroup(const ::nebula::meta::cpp2::GetGroupReq& p_req); + virtual folly::Future< ::nebula::meta::cpp2::GetGroupResp> future_getGroup(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetGroupReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::GetGroupResp> semifuture_getGroup(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetGroupReq& p_req); + virtual folly::Future>> header_future_getGroup(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetGroupReq& p_req); + virtual folly::SemiFuture>> header_semifuture_getGroup(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetGroupReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::meta::cpp2::GetGroupResp> co_getGroup(const ::nebula::meta::cpp2::GetGroupReq& p_req) { + return co_getGroup(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::meta::cpp2::GetGroupResp> co_getGroup(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetGroupReq& p_req) { + return co_getGroup(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::meta::cpp2::GetGroupResp> co_getGroup(apache::thrift::RpcOptions* rpcOptions, const ::nebula::meta::cpp2::GetGroupReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = getGroupCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + getGroupImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + getGroupImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::meta::cpp2::GetGroupResp _return; + if (auto ew = recv_wrapped_getGroup(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void getGroup(folly::Function callback, const ::nebula::meta::cpp2::GetGroupReq& p_req); + + + static folly::exception_wrapper recv_wrapped_getGroup( ::nebula::meta::cpp2::GetGroupResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_getGroup( ::nebula::meta::cpp2::GetGroupResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_getGroup( ::nebula::meta::cpp2::GetGroupResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_getGroup( ::nebula::meta::cpp2::GetGroupResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void getGroupT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::GetGroupReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> getGroupCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void listGroups(std::unique_ptr callback, const ::nebula::meta::cpp2::ListGroupsReq& p_req); + virtual void listGroups(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::ListGroupsReq& p_req); + protected: + void listGroupsImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::ListGroupsReq& p_req); + public: + + virtual void sync_listGroups( ::nebula::meta::cpp2::ListGroupsResp& _return, const ::nebula::meta::cpp2::ListGroupsReq& p_req); + virtual void sync_listGroups(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ListGroupsResp& _return, const ::nebula::meta::cpp2::ListGroupsReq& p_req); + + virtual folly::Future< ::nebula::meta::cpp2::ListGroupsResp> future_listGroups(const ::nebula::meta::cpp2::ListGroupsReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ListGroupsResp> semifuture_listGroups(const ::nebula::meta::cpp2::ListGroupsReq& p_req); + virtual folly::Future< ::nebula::meta::cpp2::ListGroupsResp> future_listGroups(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListGroupsReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ListGroupsResp> semifuture_listGroups(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListGroupsReq& p_req); + virtual folly::Future>> header_future_listGroups(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListGroupsReq& p_req); + virtual folly::SemiFuture>> header_semifuture_listGroups(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListGroupsReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::meta::cpp2::ListGroupsResp> co_listGroups(const ::nebula::meta::cpp2::ListGroupsReq& p_req) { + return co_listGroups(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::meta::cpp2::ListGroupsResp> co_listGroups(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListGroupsReq& p_req) { + return co_listGroups(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::meta::cpp2::ListGroupsResp> co_listGroups(apache::thrift::RpcOptions* rpcOptions, const ::nebula::meta::cpp2::ListGroupsReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = listGroupsCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + listGroupsImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + listGroupsImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::meta::cpp2::ListGroupsResp _return; + if (auto ew = recv_wrapped_listGroups(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void listGroups(folly::Function callback, const ::nebula::meta::cpp2::ListGroupsReq& p_req); + + + static folly::exception_wrapper recv_wrapped_listGroups( ::nebula::meta::cpp2::ListGroupsResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_listGroups( ::nebula::meta::cpp2::ListGroupsResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_listGroups( ::nebula::meta::cpp2::ListGroupsResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_listGroups( ::nebula::meta::cpp2::ListGroupsResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void listGroupsT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::ListGroupsReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> listGroupsCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void createBackup(std::unique_ptr callback, const ::nebula::meta::cpp2::CreateBackupReq& p_req); + virtual void createBackup(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::CreateBackupReq& p_req); + protected: + void createBackupImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::CreateBackupReq& p_req); + public: + + virtual void sync_createBackup( ::nebula::meta::cpp2::CreateBackupResp& _return, const ::nebula::meta::cpp2::CreateBackupReq& p_req); + virtual void sync_createBackup(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::CreateBackupResp& _return, const ::nebula::meta::cpp2::CreateBackupReq& p_req); + + virtual folly::Future< ::nebula::meta::cpp2::CreateBackupResp> future_createBackup(const ::nebula::meta::cpp2::CreateBackupReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::CreateBackupResp> semifuture_createBackup(const ::nebula::meta::cpp2::CreateBackupReq& p_req); + virtual folly::Future< ::nebula::meta::cpp2::CreateBackupResp> future_createBackup(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateBackupReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::CreateBackupResp> semifuture_createBackup(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateBackupReq& p_req); + virtual folly::Future>> header_future_createBackup(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateBackupReq& p_req); + virtual folly::SemiFuture>> header_semifuture_createBackup(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateBackupReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::meta::cpp2::CreateBackupResp> co_createBackup(const ::nebula::meta::cpp2::CreateBackupReq& p_req) { + return co_createBackup(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::meta::cpp2::CreateBackupResp> co_createBackup(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateBackupReq& p_req) { + return co_createBackup(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::meta::cpp2::CreateBackupResp> co_createBackup(apache::thrift::RpcOptions* rpcOptions, const ::nebula::meta::cpp2::CreateBackupReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = createBackupCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + createBackupImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + createBackupImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::meta::cpp2::CreateBackupResp _return; + if (auto ew = recv_wrapped_createBackup(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void createBackup(folly::Function callback, const ::nebula::meta::cpp2::CreateBackupReq& p_req); + + + static folly::exception_wrapper recv_wrapped_createBackup( ::nebula::meta::cpp2::CreateBackupResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_createBackup( ::nebula::meta::cpp2::CreateBackupResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_createBackup( ::nebula::meta::cpp2::CreateBackupResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_createBackup( ::nebula::meta::cpp2::CreateBackupResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void createBackupT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::CreateBackupReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> createBackupCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void restoreMeta(std::unique_ptr callback, const ::nebula::meta::cpp2::RestoreMetaReq& p_req); + virtual void restoreMeta(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::RestoreMetaReq& p_req); + protected: + void restoreMetaImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::RestoreMetaReq& p_req); + public: + + virtual void sync_restoreMeta( ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::RestoreMetaReq& p_req); + virtual void sync_restoreMeta(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::RestoreMetaReq& p_req); + + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_restoreMeta(const ::nebula::meta::cpp2::RestoreMetaReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_restoreMeta(const ::nebula::meta::cpp2::RestoreMetaReq& p_req); + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_restoreMeta(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::RestoreMetaReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_restoreMeta(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::RestoreMetaReq& p_req); + virtual folly::Future>> header_future_restoreMeta(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::RestoreMetaReq& p_req); + virtual folly::SemiFuture>> header_semifuture_restoreMeta(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::RestoreMetaReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_restoreMeta(const ::nebula::meta::cpp2::RestoreMetaReq& p_req) { + return co_restoreMeta(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_restoreMeta(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::RestoreMetaReq& p_req) { + return co_restoreMeta(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_restoreMeta(apache::thrift::RpcOptions* rpcOptions, const ::nebula::meta::cpp2::RestoreMetaReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = restoreMetaCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + restoreMetaImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + restoreMetaImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::meta::cpp2::ExecResp _return; + if (auto ew = recv_wrapped_restoreMeta(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void restoreMeta(folly::Function callback, const ::nebula::meta::cpp2::RestoreMetaReq& p_req); + + + static folly::exception_wrapper recv_wrapped_restoreMeta( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_restoreMeta( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_restoreMeta( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_restoreMeta( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void restoreMetaT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::RestoreMetaReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> restoreMetaCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void addListener(std::unique_ptr callback, const ::nebula::meta::cpp2::AddListenerReq& p_req); + virtual void addListener(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::AddListenerReq& p_req); + protected: + void addListenerImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::AddListenerReq& p_req); + public: + + virtual void sync_addListener( ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::AddListenerReq& p_req); + virtual void sync_addListener(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::AddListenerReq& p_req); + + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_addListener(const ::nebula::meta::cpp2::AddListenerReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_addListener(const ::nebula::meta::cpp2::AddListenerReq& p_req); + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_addListener(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::AddListenerReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_addListener(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::AddListenerReq& p_req); + virtual folly::Future>> header_future_addListener(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::AddListenerReq& p_req); + virtual folly::SemiFuture>> header_semifuture_addListener(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::AddListenerReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_addListener(const ::nebula::meta::cpp2::AddListenerReq& p_req) { + return co_addListener(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_addListener(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::AddListenerReq& p_req) { + return co_addListener(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_addListener(apache::thrift::RpcOptions* rpcOptions, const ::nebula::meta::cpp2::AddListenerReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = addListenerCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + addListenerImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + addListenerImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::meta::cpp2::ExecResp _return; + if (auto ew = recv_wrapped_addListener(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void addListener(folly::Function callback, const ::nebula::meta::cpp2::AddListenerReq& p_req); + + + static folly::exception_wrapper recv_wrapped_addListener( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_addListener( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_addListener( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_addListener( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void addListenerT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::AddListenerReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> addListenerCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void removeListener(std::unique_ptr callback, const ::nebula::meta::cpp2::RemoveListenerReq& p_req); + virtual void removeListener(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::RemoveListenerReq& p_req); + protected: + void removeListenerImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::RemoveListenerReq& p_req); + public: + + virtual void sync_removeListener( ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::RemoveListenerReq& p_req); + virtual void sync_removeListener(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::RemoveListenerReq& p_req); + + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_removeListener(const ::nebula::meta::cpp2::RemoveListenerReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_removeListener(const ::nebula::meta::cpp2::RemoveListenerReq& p_req); + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_removeListener(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::RemoveListenerReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_removeListener(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::RemoveListenerReq& p_req); + virtual folly::Future>> header_future_removeListener(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::RemoveListenerReq& p_req); + virtual folly::SemiFuture>> header_semifuture_removeListener(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::RemoveListenerReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_removeListener(const ::nebula::meta::cpp2::RemoveListenerReq& p_req) { + return co_removeListener(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_removeListener(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::RemoveListenerReq& p_req) { + return co_removeListener(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_removeListener(apache::thrift::RpcOptions* rpcOptions, const ::nebula::meta::cpp2::RemoveListenerReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = removeListenerCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + removeListenerImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + removeListenerImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::meta::cpp2::ExecResp _return; + if (auto ew = recv_wrapped_removeListener(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void removeListener(folly::Function callback, const ::nebula::meta::cpp2::RemoveListenerReq& p_req); + + + static folly::exception_wrapper recv_wrapped_removeListener( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_removeListener( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_removeListener( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_removeListener( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void removeListenerT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::RemoveListenerReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> removeListenerCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void listListener(std::unique_ptr callback, const ::nebula::meta::cpp2::ListListenerReq& p_req); + virtual void listListener(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::ListListenerReq& p_req); + protected: + void listListenerImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::ListListenerReq& p_req); + public: + + virtual void sync_listListener( ::nebula::meta::cpp2::ListListenerResp& _return, const ::nebula::meta::cpp2::ListListenerReq& p_req); + virtual void sync_listListener(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ListListenerResp& _return, const ::nebula::meta::cpp2::ListListenerReq& p_req); + + virtual folly::Future< ::nebula::meta::cpp2::ListListenerResp> future_listListener(const ::nebula::meta::cpp2::ListListenerReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ListListenerResp> semifuture_listListener(const ::nebula::meta::cpp2::ListListenerReq& p_req); + virtual folly::Future< ::nebula::meta::cpp2::ListListenerResp> future_listListener(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListListenerReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ListListenerResp> semifuture_listListener(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListListenerReq& p_req); + virtual folly::Future>> header_future_listListener(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListListenerReq& p_req); + virtual folly::SemiFuture>> header_semifuture_listListener(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListListenerReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::meta::cpp2::ListListenerResp> co_listListener(const ::nebula::meta::cpp2::ListListenerReq& p_req) { + return co_listListener(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::meta::cpp2::ListListenerResp> co_listListener(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListListenerReq& p_req) { + return co_listListener(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::meta::cpp2::ListListenerResp> co_listListener(apache::thrift::RpcOptions* rpcOptions, const ::nebula::meta::cpp2::ListListenerReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = listListenerCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + listListenerImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + listListenerImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::meta::cpp2::ListListenerResp _return; + if (auto ew = recv_wrapped_listListener(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void listListener(folly::Function callback, const ::nebula::meta::cpp2::ListListenerReq& p_req); + + + static folly::exception_wrapper recv_wrapped_listListener( ::nebula::meta::cpp2::ListListenerResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_listListener( ::nebula::meta::cpp2::ListListenerResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_listListener( ::nebula::meta::cpp2::ListListenerResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_listListener( ::nebula::meta::cpp2::ListListenerResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void listListenerT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::ListListenerReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> listListenerCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void getStats(std::unique_ptr callback, const ::nebula::meta::cpp2::GetStatsReq& p_req); + virtual void getStats(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::GetStatsReq& p_req); + protected: + void getStatsImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::GetStatsReq& p_req); + public: + + virtual void sync_getStats( ::nebula::meta::cpp2::GetStatsResp& _return, const ::nebula::meta::cpp2::GetStatsReq& p_req); + virtual void sync_getStats(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::GetStatsResp& _return, const ::nebula::meta::cpp2::GetStatsReq& p_req); + + virtual folly::Future< ::nebula::meta::cpp2::GetStatsResp> future_getStats(const ::nebula::meta::cpp2::GetStatsReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::GetStatsResp> semifuture_getStats(const ::nebula::meta::cpp2::GetStatsReq& p_req); + virtual folly::Future< ::nebula::meta::cpp2::GetStatsResp> future_getStats(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetStatsReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::GetStatsResp> semifuture_getStats(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetStatsReq& p_req); + virtual folly::Future>> header_future_getStats(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetStatsReq& p_req); + virtual folly::SemiFuture>> header_semifuture_getStats(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetStatsReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::meta::cpp2::GetStatsResp> co_getStats(const ::nebula::meta::cpp2::GetStatsReq& p_req) { + return co_getStats(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::meta::cpp2::GetStatsResp> co_getStats(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetStatsReq& p_req) { + return co_getStats(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::meta::cpp2::GetStatsResp> co_getStats(apache::thrift::RpcOptions* rpcOptions, const ::nebula::meta::cpp2::GetStatsReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = getStatsCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + getStatsImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + getStatsImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::meta::cpp2::GetStatsResp _return; + if (auto ew = recv_wrapped_getStats(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void getStats(folly::Function callback, const ::nebula::meta::cpp2::GetStatsReq& p_req); + + + static folly::exception_wrapper recv_wrapped_getStats( ::nebula::meta::cpp2::GetStatsResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_getStats( ::nebula::meta::cpp2::GetStatsResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_getStats( ::nebula::meta::cpp2::GetStatsResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_getStats( ::nebula::meta::cpp2::GetStatsResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void getStatsT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::GetStatsReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> getStatsCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void signInFTService(std::unique_ptr callback, const ::nebula::meta::cpp2::SignInFTServiceReq& p_req); + virtual void signInFTService(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::SignInFTServiceReq& p_req); + protected: + void signInFTServiceImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::SignInFTServiceReq& p_req); + public: + + virtual void sync_signInFTService( ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::SignInFTServiceReq& p_req); + virtual void sync_signInFTService(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::SignInFTServiceReq& p_req); + + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_signInFTService(const ::nebula::meta::cpp2::SignInFTServiceReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_signInFTService(const ::nebula::meta::cpp2::SignInFTServiceReq& p_req); + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_signInFTService(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::SignInFTServiceReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_signInFTService(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::SignInFTServiceReq& p_req); + virtual folly::Future>> header_future_signInFTService(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::SignInFTServiceReq& p_req); + virtual folly::SemiFuture>> header_semifuture_signInFTService(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::SignInFTServiceReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_signInFTService(const ::nebula::meta::cpp2::SignInFTServiceReq& p_req) { + return co_signInFTService(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_signInFTService(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::SignInFTServiceReq& p_req) { + return co_signInFTService(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_signInFTService(apache::thrift::RpcOptions* rpcOptions, const ::nebula::meta::cpp2::SignInFTServiceReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = signInFTServiceCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + signInFTServiceImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + signInFTServiceImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::meta::cpp2::ExecResp _return; + if (auto ew = recv_wrapped_signInFTService(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void signInFTService(folly::Function callback, const ::nebula::meta::cpp2::SignInFTServiceReq& p_req); + + + static folly::exception_wrapper recv_wrapped_signInFTService( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_signInFTService( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_signInFTService( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_signInFTService( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void signInFTServiceT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::SignInFTServiceReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> signInFTServiceCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void signOutFTService(std::unique_ptr callback, const ::nebula::meta::cpp2::SignOutFTServiceReq& p_req); + virtual void signOutFTService(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::SignOutFTServiceReq& p_req); + protected: + void signOutFTServiceImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::SignOutFTServiceReq& p_req); + public: + + virtual void sync_signOutFTService( ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::SignOutFTServiceReq& p_req); + virtual void sync_signOutFTService(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::SignOutFTServiceReq& p_req); + + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_signOutFTService(const ::nebula::meta::cpp2::SignOutFTServiceReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_signOutFTService(const ::nebula::meta::cpp2::SignOutFTServiceReq& p_req); + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_signOutFTService(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::SignOutFTServiceReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_signOutFTService(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::SignOutFTServiceReq& p_req); + virtual folly::Future>> header_future_signOutFTService(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::SignOutFTServiceReq& p_req); + virtual folly::SemiFuture>> header_semifuture_signOutFTService(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::SignOutFTServiceReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_signOutFTService(const ::nebula::meta::cpp2::SignOutFTServiceReq& p_req) { + return co_signOutFTService(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_signOutFTService(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::SignOutFTServiceReq& p_req) { + return co_signOutFTService(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_signOutFTService(apache::thrift::RpcOptions* rpcOptions, const ::nebula::meta::cpp2::SignOutFTServiceReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = signOutFTServiceCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + signOutFTServiceImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + signOutFTServiceImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::meta::cpp2::ExecResp _return; + if (auto ew = recv_wrapped_signOutFTService(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void signOutFTService(folly::Function callback, const ::nebula::meta::cpp2::SignOutFTServiceReq& p_req); + + + static folly::exception_wrapper recv_wrapped_signOutFTService( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_signOutFTService( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_signOutFTService( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_signOutFTService( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void signOutFTServiceT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::SignOutFTServiceReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> signOutFTServiceCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void listFTClients(std::unique_ptr callback, const ::nebula::meta::cpp2::ListFTClientsReq& p_req); + virtual void listFTClients(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::ListFTClientsReq& p_req); + protected: + void listFTClientsImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::ListFTClientsReq& p_req); + public: + + virtual void sync_listFTClients( ::nebula::meta::cpp2::ListFTClientsResp& _return, const ::nebula::meta::cpp2::ListFTClientsReq& p_req); + virtual void sync_listFTClients(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ListFTClientsResp& _return, const ::nebula::meta::cpp2::ListFTClientsReq& p_req); + + virtual folly::Future< ::nebula::meta::cpp2::ListFTClientsResp> future_listFTClients(const ::nebula::meta::cpp2::ListFTClientsReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ListFTClientsResp> semifuture_listFTClients(const ::nebula::meta::cpp2::ListFTClientsReq& p_req); + virtual folly::Future< ::nebula::meta::cpp2::ListFTClientsResp> future_listFTClients(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListFTClientsReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ListFTClientsResp> semifuture_listFTClients(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListFTClientsReq& p_req); + virtual folly::Future>> header_future_listFTClients(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListFTClientsReq& p_req); + virtual folly::SemiFuture>> header_semifuture_listFTClients(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListFTClientsReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::meta::cpp2::ListFTClientsResp> co_listFTClients(const ::nebula::meta::cpp2::ListFTClientsReq& p_req) { + return co_listFTClients(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::meta::cpp2::ListFTClientsResp> co_listFTClients(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListFTClientsReq& p_req) { + return co_listFTClients(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::meta::cpp2::ListFTClientsResp> co_listFTClients(apache::thrift::RpcOptions* rpcOptions, const ::nebula::meta::cpp2::ListFTClientsReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = listFTClientsCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + listFTClientsImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + listFTClientsImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::meta::cpp2::ListFTClientsResp _return; + if (auto ew = recv_wrapped_listFTClients(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void listFTClients(folly::Function callback, const ::nebula::meta::cpp2::ListFTClientsReq& p_req); + + + static folly::exception_wrapper recv_wrapped_listFTClients( ::nebula::meta::cpp2::ListFTClientsResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_listFTClients( ::nebula::meta::cpp2::ListFTClientsResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_listFTClients( ::nebula::meta::cpp2::ListFTClientsResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_listFTClients( ::nebula::meta::cpp2::ListFTClientsResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void listFTClientsT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::ListFTClientsReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> listFTClientsCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void createFTIndex(std::unique_ptr callback, const ::nebula::meta::cpp2::CreateFTIndexReq& p_req); + virtual void createFTIndex(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::CreateFTIndexReq& p_req); + protected: + void createFTIndexImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::CreateFTIndexReq& p_req); + public: + + virtual void sync_createFTIndex( ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::CreateFTIndexReq& p_req); + virtual void sync_createFTIndex(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::CreateFTIndexReq& p_req); + + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_createFTIndex(const ::nebula::meta::cpp2::CreateFTIndexReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_createFTIndex(const ::nebula::meta::cpp2::CreateFTIndexReq& p_req); + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_createFTIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateFTIndexReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_createFTIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateFTIndexReq& p_req); + virtual folly::Future>> header_future_createFTIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateFTIndexReq& p_req); + virtual folly::SemiFuture>> header_semifuture_createFTIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateFTIndexReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_createFTIndex(const ::nebula::meta::cpp2::CreateFTIndexReq& p_req) { + return co_createFTIndex(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_createFTIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateFTIndexReq& p_req) { + return co_createFTIndex(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_createFTIndex(apache::thrift::RpcOptions* rpcOptions, const ::nebula::meta::cpp2::CreateFTIndexReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = createFTIndexCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + createFTIndexImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + createFTIndexImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::meta::cpp2::ExecResp _return; + if (auto ew = recv_wrapped_createFTIndex(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void createFTIndex(folly::Function callback, const ::nebula::meta::cpp2::CreateFTIndexReq& p_req); + + + static folly::exception_wrapper recv_wrapped_createFTIndex( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_createFTIndex( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_createFTIndex( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_createFTIndex( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void createFTIndexT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::CreateFTIndexReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> createFTIndexCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void dropFTIndex(std::unique_ptr callback, const ::nebula::meta::cpp2::DropFTIndexReq& p_req); + virtual void dropFTIndex(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::DropFTIndexReq& p_req); + protected: + void dropFTIndexImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::DropFTIndexReq& p_req); + public: + + virtual void sync_dropFTIndex( ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::DropFTIndexReq& p_req); + virtual void sync_dropFTIndex(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::DropFTIndexReq& p_req); + + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_dropFTIndex(const ::nebula::meta::cpp2::DropFTIndexReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_dropFTIndex(const ::nebula::meta::cpp2::DropFTIndexReq& p_req); + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_dropFTIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropFTIndexReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_dropFTIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropFTIndexReq& p_req); + virtual folly::Future>> header_future_dropFTIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropFTIndexReq& p_req); + virtual folly::SemiFuture>> header_semifuture_dropFTIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropFTIndexReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_dropFTIndex(const ::nebula::meta::cpp2::DropFTIndexReq& p_req) { + return co_dropFTIndex(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_dropFTIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::DropFTIndexReq& p_req) { + return co_dropFTIndex(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_dropFTIndex(apache::thrift::RpcOptions* rpcOptions, const ::nebula::meta::cpp2::DropFTIndexReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = dropFTIndexCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + dropFTIndexImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + dropFTIndexImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::meta::cpp2::ExecResp _return; + if (auto ew = recv_wrapped_dropFTIndex(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void dropFTIndex(folly::Function callback, const ::nebula::meta::cpp2::DropFTIndexReq& p_req); + + + static folly::exception_wrapper recv_wrapped_dropFTIndex( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_dropFTIndex( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_dropFTIndex( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_dropFTIndex( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void dropFTIndexT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::DropFTIndexReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> dropFTIndexCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void listFTIndexes(std::unique_ptr callback, const ::nebula::meta::cpp2::ListFTIndexesReq& p_req); + virtual void listFTIndexes(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::ListFTIndexesReq& p_req); + protected: + void listFTIndexesImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::ListFTIndexesReq& p_req); + public: + + virtual void sync_listFTIndexes( ::nebula::meta::cpp2::ListFTIndexesResp& _return, const ::nebula::meta::cpp2::ListFTIndexesReq& p_req); + virtual void sync_listFTIndexes(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ListFTIndexesResp& _return, const ::nebula::meta::cpp2::ListFTIndexesReq& p_req); + + virtual folly::Future< ::nebula::meta::cpp2::ListFTIndexesResp> future_listFTIndexes(const ::nebula::meta::cpp2::ListFTIndexesReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ListFTIndexesResp> semifuture_listFTIndexes(const ::nebula::meta::cpp2::ListFTIndexesReq& p_req); + virtual folly::Future< ::nebula::meta::cpp2::ListFTIndexesResp> future_listFTIndexes(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListFTIndexesReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ListFTIndexesResp> semifuture_listFTIndexes(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListFTIndexesReq& p_req); + virtual folly::Future>> header_future_listFTIndexes(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListFTIndexesReq& p_req); + virtual folly::SemiFuture>> header_semifuture_listFTIndexes(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListFTIndexesReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::meta::cpp2::ListFTIndexesResp> co_listFTIndexes(const ::nebula::meta::cpp2::ListFTIndexesReq& p_req) { + return co_listFTIndexes(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::meta::cpp2::ListFTIndexesResp> co_listFTIndexes(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListFTIndexesReq& p_req) { + return co_listFTIndexes(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::meta::cpp2::ListFTIndexesResp> co_listFTIndexes(apache::thrift::RpcOptions* rpcOptions, const ::nebula::meta::cpp2::ListFTIndexesReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = listFTIndexesCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + listFTIndexesImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + listFTIndexesImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::meta::cpp2::ListFTIndexesResp _return; + if (auto ew = recv_wrapped_listFTIndexes(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void listFTIndexes(folly::Function callback, const ::nebula::meta::cpp2::ListFTIndexesReq& p_req); + + + static folly::exception_wrapper recv_wrapped_listFTIndexes( ::nebula::meta::cpp2::ListFTIndexesResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_listFTIndexes( ::nebula::meta::cpp2::ListFTIndexesResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_listFTIndexes( ::nebula::meta::cpp2::ListFTIndexesResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_listFTIndexes( ::nebula::meta::cpp2::ListFTIndexesResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void listFTIndexesT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::ListFTIndexesReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> listFTIndexesCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void createSession(std::unique_ptr callback, const ::nebula::meta::cpp2::CreateSessionReq& p_req); + virtual void createSession(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::CreateSessionReq& p_req); + protected: + void createSessionImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::CreateSessionReq& p_req); + public: + + virtual void sync_createSession( ::nebula::meta::cpp2::CreateSessionResp& _return, const ::nebula::meta::cpp2::CreateSessionReq& p_req); + virtual void sync_createSession(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::CreateSessionResp& _return, const ::nebula::meta::cpp2::CreateSessionReq& p_req); + + virtual folly::Future< ::nebula::meta::cpp2::CreateSessionResp> future_createSession(const ::nebula::meta::cpp2::CreateSessionReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::CreateSessionResp> semifuture_createSession(const ::nebula::meta::cpp2::CreateSessionReq& p_req); + virtual folly::Future< ::nebula::meta::cpp2::CreateSessionResp> future_createSession(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateSessionReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::CreateSessionResp> semifuture_createSession(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateSessionReq& p_req); + virtual folly::Future>> header_future_createSession(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateSessionReq& p_req); + virtual folly::SemiFuture>> header_semifuture_createSession(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateSessionReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::meta::cpp2::CreateSessionResp> co_createSession(const ::nebula::meta::cpp2::CreateSessionReq& p_req) { + return co_createSession(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::meta::cpp2::CreateSessionResp> co_createSession(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::CreateSessionReq& p_req) { + return co_createSession(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::meta::cpp2::CreateSessionResp> co_createSession(apache::thrift::RpcOptions* rpcOptions, const ::nebula::meta::cpp2::CreateSessionReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = createSessionCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + createSessionImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + createSessionImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::meta::cpp2::CreateSessionResp _return; + if (auto ew = recv_wrapped_createSession(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void createSession(folly::Function callback, const ::nebula::meta::cpp2::CreateSessionReq& p_req); + + + static folly::exception_wrapper recv_wrapped_createSession( ::nebula::meta::cpp2::CreateSessionResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_createSession( ::nebula::meta::cpp2::CreateSessionResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_createSession( ::nebula::meta::cpp2::CreateSessionResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_createSession( ::nebula::meta::cpp2::CreateSessionResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void createSessionT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::CreateSessionReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> createSessionCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void updateSessions(std::unique_ptr callback, const ::nebula::meta::cpp2::UpdateSessionsReq& p_req); + virtual void updateSessions(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::UpdateSessionsReq& p_req); + protected: + void updateSessionsImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::UpdateSessionsReq& p_req); + public: + + virtual void sync_updateSessions( ::nebula::meta::cpp2::UpdateSessionsResp& _return, const ::nebula::meta::cpp2::UpdateSessionsReq& p_req); + virtual void sync_updateSessions(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::UpdateSessionsResp& _return, const ::nebula::meta::cpp2::UpdateSessionsReq& p_req); + + virtual folly::Future< ::nebula::meta::cpp2::UpdateSessionsResp> future_updateSessions(const ::nebula::meta::cpp2::UpdateSessionsReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::UpdateSessionsResp> semifuture_updateSessions(const ::nebula::meta::cpp2::UpdateSessionsReq& p_req); + virtual folly::Future< ::nebula::meta::cpp2::UpdateSessionsResp> future_updateSessions(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::UpdateSessionsReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::UpdateSessionsResp> semifuture_updateSessions(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::UpdateSessionsReq& p_req); + virtual folly::Future>> header_future_updateSessions(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::UpdateSessionsReq& p_req); + virtual folly::SemiFuture>> header_semifuture_updateSessions(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::UpdateSessionsReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::meta::cpp2::UpdateSessionsResp> co_updateSessions(const ::nebula::meta::cpp2::UpdateSessionsReq& p_req) { + return co_updateSessions(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::meta::cpp2::UpdateSessionsResp> co_updateSessions(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::UpdateSessionsReq& p_req) { + return co_updateSessions(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::meta::cpp2::UpdateSessionsResp> co_updateSessions(apache::thrift::RpcOptions* rpcOptions, const ::nebula::meta::cpp2::UpdateSessionsReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = updateSessionsCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + updateSessionsImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + updateSessionsImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::meta::cpp2::UpdateSessionsResp _return; + if (auto ew = recv_wrapped_updateSessions(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void updateSessions(folly::Function callback, const ::nebula::meta::cpp2::UpdateSessionsReq& p_req); + + + static folly::exception_wrapper recv_wrapped_updateSessions( ::nebula::meta::cpp2::UpdateSessionsResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_updateSessions( ::nebula::meta::cpp2::UpdateSessionsResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_updateSessions( ::nebula::meta::cpp2::UpdateSessionsResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_updateSessions( ::nebula::meta::cpp2::UpdateSessionsResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void updateSessionsT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::UpdateSessionsReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> updateSessionsCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void listSessions(std::unique_ptr callback, const ::nebula::meta::cpp2::ListSessionsReq& p_req); + virtual void listSessions(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::ListSessionsReq& p_req); + protected: + void listSessionsImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::ListSessionsReq& p_req); + public: + + virtual void sync_listSessions( ::nebula::meta::cpp2::ListSessionsResp& _return, const ::nebula::meta::cpp2::ListSessionsReq& p_req); + virtual void sync_listSessions(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ListSessionsResp& _return, const ::nebula::meta::cpp2::ListSessionsReq& p_req); + + virtual folly::Future< ::nebula::meta::cpp2::ListSessionsResp> future_listSessions(const ::nebula::meta::cpp2::ListSessionsReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ListSessionsResp> semifuture_listSessions(const ::nebula::meta::cpp2::ListSessionsReq& p_req); + virtual folly::Future< ::nebula::meta::cpp2::ListSessionsResp> future_listSessions(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListSessionsReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ListSessionsResp> semifuture_listSessions(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListSessionsReq& p_req); + virtual folly::Future>> header_future_listSessions(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListSessionsReq& p_req); + virtual folly::SemiFuture>> header_semifuture_listSessions(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListSessionsReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::meta::cpp2::ListSessionsResp> co_listSessions(const ::nebula::meta::cpp2::ListSessionsReq& p_req) { + return co_listSessions(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::meta::cpp2::ListSessionsResp> co_listSessions(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListSessionsReq& p_req) { + return co_listSessions(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::meta::cpp2::ListSessionsResp> co_listSessions(apache::thrift::RpcOptions* rpcOptions, const ::nebula::meta::cpp2::ListSessionsReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = listSessionsCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + listSessionsImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + listSessionsImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::meta::cpp2::ListSessionsResp _return; + if (auto ew = recv_wrapped_listSessions(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void listSessions(folly::Function callback, const ::nebula::meta::cpp2::ListSessionsReq& p_req); + + + static folly::exception_wrapper recv_wrapped_listSessions( ::nebula::meta::cpp2::ListSessionsResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_listSessions( ::nebula::meta::cpp2::ListSessionsResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_listSessions( ::nebula::meta::cpp2::ListSessionsResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_listSessions( ::nebula::meta::cpp2::ListSessionsResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void listSessionsT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::ListSessionsReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> listSessionsCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void getSession(std::unique_ptr callback, const ::nebula::meta::cpp2::GetSessionReq& p_req); + virtual void getSession(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::GetSessionReq& p_req); + protected: + void getSessionImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::GetSessionReq& p_req); + public: + + virtual void sync_getSession( ::nebula::meta::cpp2::GetSessionResp& _return, const ::nebula::meta::cpp2::GetSessionReq& p_req); + virtual void sync_getSession(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::GetSessionResp& _return, const ::nebula::meta::cpp2::GetSessionReq& p_req); + + virtual folly::Future< ::nebula::meta::cpp2::GetSessionResp> future_getSession(const ::nebula::meta::cpp2::GetSessionReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::GetSessionResp> semifuture_getSession(const ::nebula::meta::cpp2::GetSessionReq& p_req); + virtual folly::Future< ::nebula::meta::cpp2::GetSessionResp> future_getSession(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetSessionReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::GetSessionResp> semifuture_getSession(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetSessionReq& p_req); + virtual folly::Future>> header_future_getSession(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetSessionReq& p_req); + virtual folly::SemiFuture>> header_semifuture_getSession(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetSessionReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::meta::cpp2::GetSessionResp> co_getSession(const ::nebula::meta::cpp2::GetSessionReq& p_req) { + return co_getSession(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::meta::cpp2::GetSessionResp> co_getSession(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetSessionReq& p_req) { + return co_getSession(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::meta::cpp2::GetSessionResp> co_getSession(apache::thrift::RpcOptions* rpcOptions, const ::nebula::meta::cpp2::GetSessionReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = getSessionCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + getSessionImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + getSessionImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::meta::cpp2::GetSessionResp _return; + if (auto ew = recv_wrapped_getSession(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void getSession(folly::Function callback, const ::nebula::meta::cpp2::GetSessionReq& p_req); + + + static folly::exception_wrapper recv_wrapped_getSession( ::nebula::meta::cpp2::GetSessionResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_getSession( ::nebula::meta::cpp2::GetSessionResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_getSession( ::nebula::meta::cpp2::GetSessionResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_getSession( ::nebula::meta::cpp2::GetSessionResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void getSessionT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::GetSessionReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> getSessionCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void removeSession(std::unique_ptr callback, const ::nebula::meta::cpp2::RemoveSessionReq& p_req); + virtual void removeSession(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::RemoveSessionReq& p_req); + protected: + void removeSessionImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::RemoveSessionReq& p_req); + public: + + virtual void sync_removeSession( ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::RemoveSessionReq& p_req); + virtual void sync_removeSession(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::RemoveSessionReq& p_req); + + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_removeSession(const ::nebula::meta::cpp2::RemoveSessionReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_removeSession(const ::nebula::meta::cpp2::RemoveSessionReq& p_req); + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_removeSession(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::RemoveSessionReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_removeSession(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::RemoveSessionReq& p_req); + virtual folly::Future>> header_future_removeSession(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::RemoveSessionReq& p_req); + virtual folly::SemiFuture>> header_semifuture_removeSession(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::RemoveSessionReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_removeSession(const ::nebula::meta::cpp2::RemoveSessionReq& p_req) { + return co_removeSession(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_removeSession(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::RemoveSessionReq& p_req) { + return co_removeSession(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_removeSession(apache::thrift::RpcOptions* rpcOptions, const ::nebula::meta::cpp2::RemoveSessionReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = removeSessionCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + removeSessionImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + removeSessionImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::meta::cpp2::ExecResp _return; + if (auto ew = recv_wrapped_removeSession(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void removeSession(folly::Function callback, const ::nebula::meta::cpp2::RemoveSessionReq& p_req); + + + static folly::exception_wrapper recv_wrapped_removeSession( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_removeSession( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_removeSession( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_removeSession( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void removeSessionT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::RemoveSessionReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> removeSessionCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void killQuery(std::unique_ptr callback, const ::nebula::meta::cpp2::KillQueryReq& p_req); + virtual void killQuery(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::KillQueryReq& p_req); + protected: + void killQueryImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::KillQueryReq& p_req); + public: + + virtual void sync_killQuery( ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::KillQueryReq& p_req); + virtual void sync_killQuery(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::KillQueryReq& p_req); + + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_killQuery(const ::nebula::meta::cpp2::KillQueryReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_killQuery(const ::nebula::meta::cpp2::KillQueryReq& p_req); + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_killQuery(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::KillQueryReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_killQuery(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::KillQueryReq& p_req); + virtual folly::Future>> header_future_killQuery(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::KillQueryReq& p_req); + virtual folly::SemiFuture>> header_semifuture_killQuery(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::KillQueryReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_killQuery(const ::nebula::meta::cpp2::KillQueryReq& p_req) { + return co_killQuery(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_killQuery(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::KillQueryReq& p_req) { + return co_killQuery(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_killQuery(apache::thrift::RpcOptions* rpcOptions, const ::nebula::meta::cpp2::KillQueryReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = killQueryCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + killQueryImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + killQueryImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::meta::cpp2::ExecResp _return; + if (auto ew = recv_wrapped_killQuery(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void killQuery(folly::Function callback, const ::nebula::meta::cpp2::KillQueryReq& p_req); + + + static folly::exception_wrapper recv_wrapped_killQuery( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_killQuery( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_killQuery( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_killQuery( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void killQueryT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::KillQueryReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> killQueryCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void reportTaskFinish(std::unique_ptr callback, const ::nebula::meta::cpp2::ReportTaskReq& p_req); + virtual void reportTaskFinish(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::ReportTaskReq& p_req); + protected: + void reportTaskFinishImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::ReportTaskReq& p_req); + public: + + virtual void sync_reportTaskFinish( ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::ReportTaskReq& p_req); + virtual void sync_reportTaskFinish(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ExecResp& _return, const ::nebula::meta::cpp2::ReportTaskReq& p_req); + + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_reportTaskFinish(const ::nebula::meta::cpp2::ReportTaskReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_reportTaskFinish(const ::nebula::meta::cpp2::ReportTaskReq& p_req); + virtual folly::Future< ::nebula::meta::cpp2::ExecResp> future_reportTaskFinish(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ReportTaskReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ExecResp> semifuture_reportTaskFinish(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ReportTaskReq& p_req); + virtual folly::Future>> header_future_reportTaskFinish(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ReportTaskReq& p_req); + virtual folly::SemiFuture>> header_semifuture_reportTaskFinish(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ReportTaskReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_reportTaskFinish(const ::nebula::meta::cpp2::ReportTaskReq& p_req) { + return co_reportTaskFinish(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_reportTaskFinish(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ReportTaskReq& p_req) { + return co_reportTaskFinish(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::meta::cpp2::ExecResp> co_reportTaskFinish(apache::thrift::RpcOptions* rpcOptions, const ::nebula::meta::cpp2::ReportTaskReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = reportTaskFinishCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + reportTaskFinishImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + reportTaskFinishImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::meta::cpp2::ExecResp _return; + if (auto ew = recv_wrapped_reportTaskFinish(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void reportTaskFinish(folly::Function callback, const ::nebula::meta::cpp2::ReportTaskReq& p_req); + + + static folly::exception_wrapper recv_wrapped_reportTaskFinish( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_reportTaskFinish( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_reportTaskFinish( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_reportTaskFinish( ::nebula::meta::cpp2::ExecResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void reportTaskFinishT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::ReportTaskReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> reportTaskFinishCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void listCluster(std::unique_ptr callback, const ::nebula::meta::cpp2::ListClusterInfoReq& p_req); + virtual void listCluster(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::ListClusterInfoReq& p_req); + protected: + void listClusterImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::ListClusterInfoReq& p_req); + public: + + virtual void sync_listCluster( ::nebula::meta::cpp2::ListClusterInfoResp& _return, const ::nebula::meta::cpp2::ListClusterInfoReq& p_req); + virtual void sync_listCluster(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::ListClusterInfoResp& _return, const ::nebula::meta::cpp2::ListClusterInfoReq& p_req); + + virtual folly::Future< ::nebula::meta::cpp2::ListClusterInfoResp> future_listCluster(const ::nebula::meta::cpp2::ListClusterInfoReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ListClusterInfoResp> semifuture_listCluster(const ::nebula::meta::cpp2::ListClusterInfoReq& p_req); + virtual folly::Future< ::nebula::meta::cpp2::ListClusterInfoResp> future_listCluster(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListClusterInfoReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::ListClusterInfoResp> semifuture_listCluster(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListClusterInfoReq& p_req); + virtual folly::Future>> header_future_listCluster(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListClusterInfoReq& p_req); + virtual folly::SemiFuture>> header_semifuture_listCluster(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListClusterInfoReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::meta::cpp2::ListClusterInfoResp> co_listCluster(const ::nebula::meta::cpp2::ListClusterInfoReq& p_req) { + return co_listCluster(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::meta::cpp2::ListClusterInfoResp> co_listCluster(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::ListClusterInfoReq& p_req) { + return co_listCluster(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::meta::cpp2::ListClusterInfoResp> co_listCluster(apache::thrift::RpcOptions* rpcOptions, const ::nebula::meta::cpp2::ListClusterInfoReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = listClusterCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + listClusterImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + listClusterImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::meta::cpp2::ListClusterInfoResp _return; + if (auto ew = recv_wrapped_listCluster(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void listCluster(folly::Function callback, const ::nebula::meta::cpp2::ListClusterInfoReq& p_req); + + + static folly::exception_wrapper recv_wrapped_listCluster( ::nebula::meta::cpp2::ListClusterInfoResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_listCluster( ::nebula::meta::cpp2::ListClusterInfoResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_listCluster( ::nebula::meta::cpp2::ListClusterInfoResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_listCluster( ::nebula::meta::cpp2::ListClusterInfoResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void listClusterT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::ListClusterInfoReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> listClusterCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void getMetaDirInfo(std::unique_ptr callback, const ::nebula::meta::cpp2::GetMetaDirInfoReq& p_req); + virtual void getMetaDirInfo(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::GetMetaDirInfoReq& p_req); + protected: + void getMetaDirInfoImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::GetMetaDirInfoReq& p_req); + public: + + virtual void sync_getMetaDirInfo( ::nebula::meta::cpp2::GetMetaDirInfoResp& _return, const ::nebula::meta::cpp2::GetMetaDirInfoReq& p_req); + virtual void sync_getMetaDirInfo(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::GetMetaDirInfoResp& _return, const ::nebula::meta::cpp2::GetMetaDirInfoReq& p_req); + + virtual folly::Future< ::nebula::meta::cpp2::GetMetaDirInfoResp> future_getMetaDirInfo(const ::nebula::meta::cpp2::GetMetaDirInfoReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::GetMetaDirInfoResp> semifuture_getMetaDirInfo(const ::nebula::meta::cpp2::GetMetaDirInfoReq& p_req); + virtual folly::Future< ::nebula::meta::cpp2::GetMetaDirInfoResp> future_getMetaDirInfo(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetMetaDirInfoReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::GetMetaDirInfoResp> semifuture_getMetaDirInfo(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetMetaDirInfoReq& p_req); + virtual folly::Future>> header_future_getMetaDirInfo(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetMetaDirInfoReq& p_req); + virtual folly::SemiFuture>> header_semifuture_getMetaDirInfo(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetMetaDirInfoReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::meta::cpp2::GetMetaDirInfoResp> co_getMetaDirInfo(const ::nebula::meta::cpp2::GetMetaDirInfoReq& p_req) { + return co_getMetaDirInfo(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::meta::cpp2::GetMetaDirInfoResp> co_getMetaDirInfo(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::GetMetaDirInfoReq& p_req) { + return co_getMetaDirInfo(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::meta::cpp2::GetMetaDirInfoResp> co_getMetaDirInfo(apache::thrift::RpcOptions* rpcOptions, const ::nebula::meta::cpp2::GetMetaDirInfoReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = getMetaDirInfoCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + getMetaDirInfoImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + getMetaDirInfoImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::meta::cpp2::GetMetaDirInfoResp _return; + if (auto ew = recv_wrapped_getMetaDirInfo(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void getMetaDirInfo(folly::Function callback, const ::nebula::meta::cpp2::GetMetaDirInfoReq& p_req); + + + static folly::exception_wrapper recv_wrapped_getMetaDirInfo( ::nebula::meta::cpp2::GetMetaDirInfoResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_getMetaDirInfo( ::nebula::meta::cpp2::GetMetaDirInfoResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_getMetaDirInfo( ::nebula::meta::cpp2::GetMetaDirInfoResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_getMetaDirInfo( ::nebula::meta::cpp2::GetMetaDirInfoResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void getMetaDirInfoT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::GetMetaDirInfoReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> getMetaDirInfoCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void verifyClientVersion(std::unique_ptr callback, const ::nebula::meta::cpp2::VerifyClientVersionReq& p_req); + virtual void verifyClientVersion(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::meta::cpp2::VerifyClientVersionReq& p_req); + protected: + void verifyClientVersionImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::VerifyClientVersionReq& p_req); + public: + + virtual void sync_verifyClientVersion( ::nebula::meta::cpp2::VerifyClientVersionResp& _return, const ::nebula::meta::cpp2::VerifyClientVersionReq& p_req); + virtual void sync_verifyClientVersion(apache::thrift::RpcOptions& rpcOptions, ::nebula::meta::cpp2::VerifyClientVersionResp& _return, const ::nebula::meta::cpp2::VerifyClientVersionReq& p_req); + + virtual folly::Future< ::nebula::meta::cpp2::VerifyClientVersionResp> future_verifyClientVersion(const ::nebula::meta::cpp2::VerifyClientVersionReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::VerifyClientVersionResp> semifuture_verifyClientVersion(const ::nebula::meta::cpp2::VerifyClientVersionReq& p_req); + virtual folly::Future< ::nebula::meta::cpp2::VerifyClientVersionResp> future_verifyClientVersion(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::VerifyClientVersionReq& p_req); + virtual folly::SemiFuture< ::nebula::meta::cpp2::VerifyClientVersionResp> semifuture_verifyClientVersion(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::VerifyClientVersionReq& p_req); + virtual folly::Future>> header_future_verifyClientVersion(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::VerifyClientVersionReq& p_req); + virtual folly::SemiFuture>> header_semifuture_verifyClientVersion(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::VerifyClientVersionReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::meta::cpp2::VerifyClientVersionResp> co_verifyClientVersion(const ::nebula::meta::cpp2::VerifyClientVersionReq& p_req) { + return co_verifyClientVersion(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::meta::cpp2::VerifyClientVersionResp> co_verifyClientVersion(apache::thrift::RpcOptions& rpcOptions, const ::nebula::meta::cpp2::VerifyClientVersionReq& p_req) { + return co_verifyClientVersion(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::meta::cpp2::VerifyClientVersionResp> co_verifyClientVersion(apache::thrift::RpcOptions* rpcOptions, const ::nebula::meta::cpp2::VerifyClientVersionReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = verifyClientVersionCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + verifyClientVersionImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + verifyClientVersionImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::meta::cpp2::VerifyClientVersionResp _return; + if (auto ew = recv_wrapped_verifyClientVersion(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void verifyClientVersion(folly::Function callback, const ::nebula::meta::cpp2::VerifyClientVersionReq& p_req); + + + static folly::exception_wrapper recv_wrapped_verifyClientVersion( ::nebula::meta::cpp2::VerifyClientVersionResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_verifyClientVersion( ::nebula::meta::cpp2::VerifyClientVersionResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_verifyClientVersion( ::nebula::meta::cpp2::VerifyClientVersionResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_verifyClientVersion( ::nebula::meta::cpp2::VerifyClientVersionResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void verifyClientVersionT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::meta::cpp2::VerifyClientVersionReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> verifyClientVersionCtx(apache::thrift::RpcOptions* rpcOptions); + public: +}; + +}}} // nebula::meta::cpp2 diff --git a/src/interface/gen-cpp2/MetaService_custom_protocol.h b/src/interface/gen-cpp2/MetaService_custom_protocol.h new file mode 100644 index 00000000..f62fb5e7 --- /dev/null +++ b/src/interface/gen-cpp2/MetaService_custom_protocol.h @@ -0,0 +1,18 @@ +/** + * Autogenerated by Thrift for meta.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#pragma once + +/** + * This header file includes the tcc files of the corresponding header file + * and the header files of its dependent types. Include this header file + * only when you need to use custom protocols (e.g. DebugProtocol, + * VirtualProtocol) to read/write thrift structs. + */ + +#include "MetaService.tcc" +#include "meta_types_custom_protocol.h" +#include "common_types_custom_protocol.h" diff --git a/src/interface/gen-cpp2/MetaService_processmap_binary.cpp b/src/interface/gen-cpp2/MetaService_processmap_binary.cpp new file mode 100644 index 00000000..ed8f5b08 --- /dev/null +++ b/src/interface/gen-cpp2/MetaService_processmap_binary.cpp @@ -0,0 +1,12 @@ +/** + * Autogenerated by Thrift for meta.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ + +#include "MetaService.h" +#include "MetaService.tcc" + +namespace nebula { namespace meta { namespace cpp2 { +}}} // nebula::meta::cpp2 diff --git a/src/interface/gen-cpp2/MetaService_processmap_compact.cpp b/src/interface/gen-cpp2/MetaService_processmap_compact.cpp new file mode 100644 index 00000000..ed8f5b08 --- /dev/null +++ b/src/interface/gen-cpp2/MetaService_processmap_compact.cpp @@ -0,0 +1,12 @@ +/** + * Autogenerated by Thrift for meta.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ + +#include "MetaService.h" +#include "MetaService.tcc" + +namespace nebula { namespace meta { namespace cpp2 { +}}} // nebula::meta::cpp2 diff --git a/src/interface/gen-cpp2/StorageAdminService.cpp b/src/interface/gen-cpp2/StorageAdminService.cpp new file mode 100644 index 00000000..c2f1046f --- /dev/null +++ b/src/interface/gen-cpp2/StorageAdminService.cpp @@ -0,0 +1,450 @@ +/** + * Autogenerated by Thrift for storage.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#include "StorageAdminService.h" +#include "StorageAdminService.tcc" +#include "storage_metadata.h" +#include + +namespace nebula { namespace storage { namespace cpp2 { +std::unique_ptr StorageAdminServiceSvIf::getProcessor() { + return std::make_unique(this); +} + + +void StorageAdminServiceSvIf::transLeader( ::nebula::storage::cpp2::AdminExecResp& /*_return*/, const ::nebula::storage::cpp2::TransLeaderReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("transLeader"); +} + +folly::SemiFuture< ::nebula::storage::cpp2::AdminExecResp> StorageAdminServiceSvIf::semifuture_transLeader(const ::nebula::storage::cpp2::TransLeaderReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::storage::cpp2::AdminExecResp& _return) { transLeader(_return, p_req); }); +} + +folly::Future< ::nebula::storage::cpp2::AdminExecResp> StorageAdminServiceSvIf::future_transLeader(const ::nebula::storage::cpp2::TransLeaderReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_transLeader(p_req), std::move(ka)); +} + +void StorageAdminServiceSvIf::async_tm_transLeader(std::unique_ptr> callback, const ::nebula::storage::cpp2::TransLeaderReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_transLeader(p_req); + }); +} + +void StorageAdminServiceSvIf::addPart( ::nebula::storage::cpp2::AdminExecResp& /*_return*/, const ::nebula::storage::cpp2::AddPartReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("addPart"); +} + +folly::SemiFuture< ::nebula::storage::cpp2::AdminExecResp> StorageAdminServiceSvIf::semifuture_addPart(const ::nebula::storage::cpp2::AddPartReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::storage::cpp2::AdminExecResp& _return) { addPart(_return, p_req); }); +} + +folly::Future< ::nebula::storage::cpp2::AdminExecResp> StorageAdminServiceSvIf::future_addPart(const ::nebula::storage::cpp2::AddPartReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_addPart(p_req), std::move(ka)); +} + +void StorageAdminServiceSvIf::async_tm_addPart(std::unique_ptr> callback, const ::nebula::storage::cpp2::AddPartReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_addPart(p_req); + }); +} + +void StorageAdminServiceSvIf::addLearner( ::nebula::storage::cpp2::AdminExecResp& /*_return*/, const ::nebula::storage::cpp2::AddLearnerReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("addLearner"); +} + +folly::SemiFuture< ::nebula::storage::cpp2::AdminExecResp> StorageAdminServiceSvIf::semifuture_addLearner(const ::nebula::storage::cpp2::AddLearnerReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::storage::cpp2::AdminExecResp& _return) { addLearner(_return, p_req); }); +} + +folly::Future< ::nebula::storage::cpp2::AdminExecResp> StorageAdminServiceSvIf::future_addLearner(const ::nebula::storage::cpp2::AddLearnerReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_addLearner(p_req), std::move(ka)); +} + +void StorageAdminServiceSvIf::async_tm_addLearner(std::unique_ptr> callback, const ::nebula::storage::cpp2::AddLearnerReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_addLearner(p_req); + }); +} + +void StorageAdminServiceSvIf::removePart( ::nebula::storage::cpp2::AdminExecResp& /*_return*/, const ::nebula::storage::cpp2::RemovePartReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("removePart"); +} + +folly::SemiFuture< ::nebula::storage::cpp2::AdminExecResp> StorageAdminServiceSvIf::semifuture_removePart(const ::nebula::storage::cpp2::RemovePartReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::storage::cpp2::AdminExecResp& _return) { removePart(_return, p_req); }); +} + +folly::Future< ::nebula::storage::cpp2::AdminExecResp> StorageAdminServiceSvIf::future_removePart(const ::nebula::storage::cpp2::RemovePartReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_removePart(p_req), std::move(ka)); +} + +void StorageAdminServiceSvIf::async_tm_removePart(std::unique_ptr> callback, const ::nebula::storage::cpp2::RemovePartReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_removePart(p_req); + }); +} + +void StorageAdminServiceSvIf::memberChange( ::nebula::storage::cpp2::AdminExecResp& /*_return*/, const ::nebula::storage::cpp2::MemberChangeReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("memberChange"); +} + +folly::SemiFuture< ::nebula::storage::cpp2::AdminExecResp> StorageAdminServiceSvIf::semifuture_memberChange(const ::nebula::storage::cpp2::MemberChangeReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::storage::cpp2::AdminExecResp& _return) { memberChange(_return, p_req); }); +} + +folly::Future< ::nebula::storage::cpp2::AdminExecResp> StorageAdminServiceSvIf::future_memberChange(const ::nebula::storage::cpp2::MemberChangeReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_memberChange(p_req), std::move(ka)); +} + +void StorageAdminServiceSvIf::async_tm_memberChange(std::unique_ptr> callback, const ::nebula::storage::cpp2::MemberChangeReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_memberChange(p_req); + }); +} + +void StorageAdminServiceSvIf::waitingForCatchUpData( ::nebula::storage::cpp2::AdminExecResp& /*_return*/, const ::nebula::storage::cpp2::CatchUpDataReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("waitingForCatchUpData"); +} + +folly::SemiFuture< ::nebula::storage::cpp2::AdminExecResp> StorageAdminServiceSvIf::semifuture_waitingForCatchUpData(const ::nebula::storage::cpp2::CatchUpDataReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::storage::cpp2::AdminExecResp& _return) { waitingForCatchUpData(_return, p_req); }); +} + +folly::Future< ::nebula::storage::cpp2::AdminExecResp> StorageAdminServiceSvIf::future_waitingForCatchUpData(const ::nebula::storage::cpp2::CatchUpDataReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_waitingForCatchUpData(p_req), std::move(ka)); +} + +void StorageAdminServiceSvIf::async_tm_waitingForCatchUpData(std::unique_ptr> callback, const ::nebula::storage::cpp2::CatchUpDataReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_waitingForCatchUpData(p_req); + }); +} + +void StorageAdminServiceSvIf::createCheckpoint( ::nebula::storage::cpp2::CreateCPResp& /*_return*/, const ::nebula::storage::cpp2::CreateCPRequest& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("createCheckpoint"); +} + +folly::SemiFuture< ::nebula::storage::cpp2::CreateCPResp> StorageAdminServiceSvIf::semifuture_createCheckpoint(const ::nebula::storage::cpp2::CreateCPRequest& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::storage::cpp2::CreateCPResp& _return) { createCheckpoint(_return, p_req); }); +} + +folly::Future< ::nebula::storage::cpp2::CreateCPResp> StorageAdminServiceSvIf::future_createCheckpoint(const ::nebula::storage::cpp2::CreateCPRequest& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_createCheckpoint(p_req), std::move(ka)); +} + +void StorageAdminServiceSvIf::async_tm_createCheckpoint(std::unique_ptr> callback, const ::nebula::storage::cpp2::CreateCPRequest& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_createCheckpoint(p_req); + }); +} + +void StorageAdminServiceSvIf::dropCheckpoint( ::nebula::storage::cpp2::AdminExecResp& /*_return*/, const ::nebula::storage::cpp2::DropCPRequest& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("dropCheckpoint"); +} + +folly::SemiFuture< ::nebula::storage::cpp2::AdminExecResp> StorageAdminServiceSvIf::semifuture_dropCheckpoint(const ::nebula::storage::cpp2::DropCPRequest& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::storage::cpp2::AdminExecResp& _return) { dropCheckpoint(_return, p_req); }); +} + +folly::Future< ::nebula::storage::cpp2::AdminExecResp> StorageAdminServiceSvIf::future_dropCheckpoint(const ::nebula::storage::cpp2::DropCPRequest& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_dropCheckpoint(p_req), std::move(ka)); +} + +void StorageAdminServiceSvIf::async_tm_dropCheckpoint(std::unique_ptr> callback, const ::nebula::storage::cpp2::DropCPRequest& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_dropCheckpoint(p_req); + }); +} + +void StorageAdminServiceSvIf::blockingWrites( ::nebula::storage::cpp2::AdminExecResp& /*_return*/, const ::nebula::storage::cpp2::BlockingSignRequest& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("blockingWrites"); +} + +folly::SemiFuture< ::nebula::storage::cpp2::AdminExecResp> StorageAdminServiceSvIf::semifuture_blockingWrites(const ::nebula::storage::cpp2::BlockingSignRequest& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::storage::cpp2::AdminExecResp& _return) { blockingWrites(_return, p_req); }); +} + +folly::Future< ::nebula::storage::cpp2::AdminExecResp> StorageAdminServiceSvIf::future_blockingWrites(const ::nebula::storage::cpp2::BlockingSignRequest& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_blockingWrites(p_req), std::move(ka)); +} + +void StorageAdminServiceSvIf::async_tm_blockingWrites(std::unique_ptr> callback, const ::nebula::storage::cpp2::BlockingSignRequest& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_blockingWrites(p_req); + }); +} + +void StorageAdminServiceSvIf::rebuildTagIndex( ::nebula::storage::cpp2::AdminExecResp& /*_return*/, const ::nebula::storage::cpp2::RebuildIndexRequest& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("rebuildTagIndex"); +} + +folly::SemiFuture< ::nebula::storage::cpp2::AdminExecResp> StorageAdminServiceSvIf::semifuture_rebuildTagIndex(const ::nebula::storage::cpp2::RebuildIndexRequest& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::storage::cpp2::AdminExecResp& _return) { rebuildTagIndex(_return, p_req); }); +} + +folly::Future< ::nebula::storage::cpp2::AdminExecResp> StorageAdminServiceSvIf::future_rebuildTagIndex(const ::nebula::storage::cpp2::RebuildIndexRequest& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_rebuildTagIndex(p_req), std::move(ka)); +} + +void StorageAdminServiceSvIf::async_tm_rebuildTagIndex(std::unique_ptr> callback, const ::nebula::storage::cpp2::RebuildIndexRequest& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_rebuildTagIndex(p_req); + }); +} + +void StorageAdminServiceSvIf::rebuildEdgeIndex( ::nebula::storage::cpp2::AdminExecResp& /*_return*/, const ::nebula::storage::cpp2::RebuildIndexRequest& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("rebuildEdgeIndex"); +} + +folly::SemiFuture< ::nebula::storage::cpp2::AdminExecResp> StorageAdminServiceSvIf::semifuture_rebuildEdgeIndex(const ::nebula::storage::cpp2::RebuildIndexRequest& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::storage::cpp2::AdminExecResp& _return) { rebuildEdgeIndex(_return, p_req); }); +} + +folly::Future< ::nebula::storage::cpp2::AdminExecResp> StorageAdminServiceSvIf::future_rebuildEdgeIndex(const ::nebula::storage::cpp2::RebuildIndexRequest& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_rebuildEdgeIndex(p_req), std::move(ka)); +} + +void StorageAdminServiceSvIf::async_tm_rebuildEdgeIndex(std::unique_ptr> callback, const ::nebula::storage::cpp2::RebuildIndexRequest& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_rebuildEdgeIndex(p_req); + }); +} + +void StorageAdminServiceSvIf::getLeaderParts( ::nebula::storage::cpp2::GetLeaderPartsResp& /*_return*/, const ::nebula::storage::cpp2::GetLeaderReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("getLeaderParts"); +} + +folly::SemiFuture< ::nebula::storage::cpp2::GetLeaderPartsResp> StorageAdminServiceSvIf::semifuture_getLeaderParts(const ::nebula::storage::cpp2::GetLeaderReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::storage::cpp2::GetLeaderPartsResp& _return) { getLeaderParts(_return, p_req); }); +} + +folly::Future< ::nebula::storage::cpp2::GetLeaderPartsResp> StorageAdminServiceSvIf::future_getLeaderParts(const ::nebula::storage::cpp2::GetLeaderReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_getLeaderParts(p_req), std::move(ka)); +} + +void StorageAdminServiceSvIf::async_tm_getLeaderParts(std::unique_ptr> callback, const ::nebula::storage::cpp2::GetLeaderReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_getLeaderParts(p_req); + }); +} + +void StorageAdminServiceSvIf::checkPeers( ::nebula::storage::cpp2::AdminExecResp& /*_return*/, const ::nebula::storage::cpp2::CheckPeersReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("checkPeers"); +} + +folly::SemiFuture< ::nebula::storage::cpp2::AdminExecResp> StorageAdminServiceSvIf::semifuture_checkPeers(const ::nebula::storage::cpp2::CheckPeersReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::storage::cpp2::AdminExecResp& _return) { checkPeers(_return, p_req); }); +} + +folly::Future< ::nebula::storage::cpp2::AdminExecResp> StorageAdminServiceSvIf::future_checkPeers(const ::nebula::storage::cpp2::CheckPeersReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_checkPeers(p_req), std::move(ka)); +} + +void StorageAdminServiceSvIf::async_tm_checkPeers(std::unique_ptr> callback, const ::nebula::storage::cpp2::CheckPeersReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_checkPeers(p_req); + }); +} + +void StorageAdminServiceSvIf::addAdminTask( ::nebula::storage::cpp2::AdminExecResp& /*_return*/, const ::nebula::storage::cpp2::AddAdminTaskRequest& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("addAdminTask"); +} + +folly::SemiFuture< ::nebula::storage::cpp2::AdminExecResp> StorageAdminServiceSvIf::semifuture_addAdminTask(const ::nebula::storage::cpp2::AddAdminTaskRequest& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::storage::cpp2::AdminExecResp& _return) { addAdminTask(_return, p_req); }); +} + +folly::Future< ::nebula::storage::cpp2::AdminExecResp> StorageAdminServiceSvIf::future_addAdminTask(const ::nebula::storage::cpp2::AddAdminTaskRequest& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_addAdminTask(p_req), std::move(ka)); +} + +void StorageAdminServiceSvIf::async_tm_addAdminTask(std::unique_ptr> callback, const ::nebula::storage::cpp2::AddAdminTaskRequest& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_addAdminTask(p_req); + }); +} + +void StorageAdminServiceSvIf::stopAdminTask( ::nebula::storage::cpp2::AdminExecResp& /*_return*/, const ::nebula::storage::cpp2::StopAdminTaskRequest& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("stopAdminTask"); +} + +folly::SemiFuture< ::nebula::storage::cpp2::AdminExecResp> StorageAdminServiceSvIf::semifuture_stopAdminTask(const ::nebula::storage::cpp2::StopAdminTaskRequest& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::storage::cpp2::AdminExecResp& _return) { stopAdminTask(_return, p_req); }); +} + +folly::Future< ::nebula::storage::cpp2::AdminExecResp> StorageAdminServiceSvIf::future_stopAdminTask(const ::nebula::storage::cpp2::StopAdminTaskRequest& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_stopAdminTask(p_req), std::move(ka)); +} + +void StorageAdminServiceSvIf::async_tm_stopAdminTask(std::unique_ptr> callback, const ::nebula::storage::cpp2::StopAdminTaskRequest& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_stopAdminTask(p_req); + }); +} + +void StorageAdminServiceSvIf::listClusterInfo( ::nebula::storage::cpp2::ListClusterInfoResp& /*_return*/, const ::nebula::storage::cpp2::ListClusterInfoReq& /*req*/) { + apache::thrift::detail::si::throw_app_exn_unimplemented("listClusterInfo"); +} + +folly::SemiFuture< ::nebula::storage::cpp2::ListClusterInfoResp> StorageAdminServiceSvIf::semifuture_listClusterInfo(const ::nebula::storage::cpp2::ListClusterInfoReq& p_req) { + return apache::thrift::detail::si::semifuture_returning([&]( ::nebula::storage::cpp2::ListClusterInfoResp& _return) { listClusterInfo(_return, p_req); }); +} + +folly::Future< ::nebula::storage::cpp2::ListClusterInfoResp> StorageAdminServiceSvIf::future_listClusterInfo(const ::nebula::storage::cpp2::ListClusterInfoReq& p_req) { + using Source = apache::thrift::concurrency::ThreadManager::Source; + auto scope = getRequestContext()->getRequestExecutionScope(); + auto ka = getThreadManager()->getKeepAlive(std::move(scope), Source::INTERNAL); + return apache::thrift::detail::si::future(semifuture_listClusterInfo(p_req), std::move(ka)); +} + +void StorageAdminServiceSvIf::async_tm_listClusterInfo(std::unique_ptr> callback, const ::nebula::storage::cpp2::ListClusterInfoReq& p_req) { + apache::thrift::detail::si::async_tm(this, std::move(callback), [&] { + return future_listClusterInfo(p_req); + }); +} + +void StorageAdminServiceSvNull::transLeader( ::nebula::storage::cpp2::AdminExecResp& /*_return*/, const ::nebula::storage::cpp2::TransLeaderReq& /*req*/) {} + +void StorageAdminServiceSvNull::addPart( ::nebula::storage::cpp2::AdminExecResp& /*_return*/, const ::nebula::storage::cpp2::AddPartReq& /*req*/) {} + +void StorageAdminServiceSvNull::addLearner( ::nebula::storage::cpp2::AdminExecResp& /*_return*/, const ::nebula::storage::cpp2::AddLearnerReq& /*req*/) {} + +void StorageAdminServiceSvNull::removePart( ::nebula::storage::cpp2::AdminExecResp& /*_return*/, const ::nebula::storage::cpp2::RemovePartReq& /*req*/) {} + +void StorageAdminServiceSvNull::memberChange( ::nebula::storage::cpp2::AdminExecResp& /*_return*/, const ::nebula::storage::cpp2::MemberChangeReq& /*req*/) {} + +void StorageAdminServiceSvNull::waitingForCatchUpData( ::nebula::storage::cpp2::AdminExecResp& /*_return*/, const ::nebula::storage::cpp2::CatchUpDataReq& /*req*/) {} + +void StorageAdminServiceSvNull::createCheckpoint( ::nebula::storage::cpp2::CreateCPResp& /*_return*/, const ::nebula::storage::cpp2::CreateCPRequest& /*req*/) {} + +void StorageAdminServiceSvNull::dropCheckpoint( ::nebula::storage::cpp2::AdminExecResp& /*_return*/, const ::nebula::storage::cpp2::DropCPRequest& /*req*/) {} + +void StorageAdminServiceSvNull::blockingWrites( ::nebula::storage::cpp2::AdminExecResp& /*_return*/, const ::nebula::storage::cpp2::BlockingSignRequest& /*req*/) {} + +void StorageAdminServiceSvNull::rebuildTagIndex( ::nebula::storage::cpp2::AdminExecResp& /*_return*/, const ::nebula::storage::cpp2::RebuildIndexRequest& /*req*/) {} + +void StorageAdminServiceSvNull::rebuildEdgeIndex( ::nebula::storage::cpp2::AdminExecResp& /*_return*/, const ::nebula::storage::cpp2::RebuildIndexRequest& /*req*/) {} + +void StorageAdminServiceSvNull::getLeaderParts( ::nebula::storage::cpp2::GetLeaderPartsResp& /*_return*/, const ::nebula::storage::cpp2::GetLeaderReq& /*req*/) {} + +void StorageAdminServiceSvNull::checkPeers( ::nebula::storage::cpp2::AdminExecResp& /*_return*/, const ::nebula::storage::cpp2::CheckPeersReq& /*req*/) {} + +void StorageAdminServiceSvNull::addAdminTask( ::nebula::storage::cpp2::AdminExecResp& /*_return*/, const ::nebula::storage::cpp2::AddAdminTaskRequest& /*req*/) {} + +void StorageAdminServiceSvNull::stopAdminTask( ::nebula::storage::cpp2::AdminExecResp& /*_return*/, const ::nebula::storage::cpp2::StopAdminTaskRequest& /*req*/) {} + +void StorageAdminServiceSvNull::listClusterInfo( ::nebula::storage::cpp2::ListClusterInfoResp& /*_return*/, const ::nebula::storage::cpp2::ListClusterInfoReq& /*req*/) {} + + + +const char* StorageAdminServiceAsyncProcessor::getServiceName() { + return "StorageAdminService"; +} + +void StorageAdminServiceAsyncProcessor::getServiceMetadata(apache::thrift::metadata::ThriftServiceMetadataResponse& response) { + ::apache::thrift::detail::md::ServiceMetadata::gen(*response.metadata_ref(), *response.context_ref()); +} + +void StorageAdminServiceAsyncProcessor::processSerializedRequest(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::protocol::PROTOCOL_TYPES protType, apache::thrift::Cpp2RequestContext* context, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + apache::thrift::detail::ap::process(this, std::move(req), std::move(serializedRequest), protType, context, eb, tm); +} + +std::shared_ptr StorageAdminServiceAsyncProcessor::getBaseContextForRequest() { + return iface_->getBaseContextForRequest(); +} + +const StorageAdminServiceAsyncProcessor::ProcessMap& StorageAdminServiceAsyncProcessor::getBinaryProtocolProcessMap() { + return binaryProcessMap_; +} + +const StorageAdminServiceAsyncProcessor::ProcessMap StorageAdminServiceAsyncProcessor::binaryProcessMap_ { + {"transLeader", &StorageAdminServiceAsyncProcessor::setUpAndProcess_transLeader}, + {"addPart", &StorageAdminServiceAsyncProcessor::setUpAndProcess_addPart}, + {"addLearner", &StorageAdminServiceAsyncProcessor::setUpAndProcess_addLearner}, + {"removePart", &StorageAdminServiceAsyncProcessor::setUpAndProcess_removePart}, + {"memberChange", &StorageAdminServiceAsyncProcessor::setUpAndProcess_memberChange}, + {"waitingForCatchUpData", &StorageAdminServiceAsyncProcessor::setUpAndProcess_waitingForCatchUpData}, + {"createCheckpoint", &StorageAdminServiceAsyncProcessor::setUpAndProcess_createCheckpoint}, + {"dropCheckpoint", &StorageAdminServiceAsyncProcessor::setUpAndProcess_dropCheckpoint}, + {"blockingWrites", &StorageAdminServiceAsyncProcessor::setUpAndProcess_blockingWrites}, + {"rebuildTagIndex", &StorageAdminServiceAsyncProcessor::setUpAndProcess_rebuildTagIndex}, + {"rebuildEdgeIndex", &StorageAdminServiceAsyncProcessor::setUpAndProcess_rebuildEdgeIndex}, + {"getLeaderParts", &StorageAdminServiceAsyncProcessor::setUpAndProcess_getLeaderParts}, + {"checkPeers", &StorageAdminServiceAsyncProcessor::setUpAndProcess_checkPeers}, + {"addAdminTask", &StorageAdminServiceAsyncProcessor::setUpAndProcess_addAdminTask}, + {"stopAdminTask", &StorageAdminServiceAsyncProcessor::setUpAndProcess_stopAdminTask}, + {"listClusterInfo", &StorageAdminServiceAsyncProcessor::setUpAndProcess_listClusterInfo}, +}; + +const StorageAdminServiceAsyncProcessor::ProcessMap& StorageAdminServiceAsyncProcessor::getCompactProtocolProcessMap() { + return compactProcessMap_; +} + +const StorageAdminServiceAsyncProcessor::ProcessMap StorageAdminServiceAsyncProcessor::compactProcessMap_ { + {"transLeader", &StorageAdminServiceAsyncProcessor::setUpAndProcess_transLeader}, + {"addPart", &StorageAdminServiceAsyncProcessor::setUpAndProcess_addPart}, + {"addLearner", &StorageAdminServiceAsyncProcessor::setUpAndProcess_addLearner}, + {"removePart", &StorageAdminServiceAsyncProcessor::setUpAndProcess_removePart}, + {"memberChange", &StorageAdminServiceAsyncProcessor::setUpAndProcess_memberChange}, + {"waitingForCatchUpData", &StorageAdminServiceAsyncProcessor::setUpAndProcess_waitingForCatchUpData}, + {"createCheckpoint", &StorageAdminServiceAsyncProcessor::setUpAndProcess_createCheckpoint}, + {"dropCheckpoint", &StorageAdminServiceAsyncProcessor::setUpAndProcess_dropCheckpoint}, + {"blockingWrites", &StorageAdminServiceAsyncProcessor::setUpAndProcess_blockingWrites}, + {"rebuildTagIndex", &StorageAdminServiceAsyncProcessor::setUpAndProcess_rebuildTagIndex}, + {"rebuildEdgeIndex", &StorageAdminServiceAsyncProcessor::setUpAndProcess_rebuildEdgeIndex}, + {"getLeaderParts", &StorageAdminServiceAsyncProcessor::setUpAndProcess_getLeaderParts}, + {"checkPeers", &StorageAdminServiceAsyncProcessor::setUpAndProcess_checkPeers}, + {"addAdminTask", &StorageAdminServiceAsyncProcessor::setUpAndProcess_addAdminTask}, + {"stopAdminTask", &StorageAdminServiceAsyncProcessor::setUpAndProcess_stopAdminTask}, + {"listClusterInfo", &StorageAdminServiceAsyncProcessor::setUpAndProcess_listClusterInfo}, +}; + +}}} // nebula::storage::cpp2 diff --git a/src/interface/gen-cpp2/StorageAdminService.h b/src/interface/gen-cpp2/StorageAdminService.h new file mode 100644 index 00000000..7c90bc08 --- /dev/null +++ b/src/interface/gen-cpp2/StorageAdminService.h @@ -0,0 +1,331 @@ +/** + * Autogenerated by Thrift for storage.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#pragma once + +#include + +#include "StorageAdminServiceAsyncClient.h" +#include "storage_types.h" +#include "common_types.h" +#include "meta_types.h" + +namespace folly { + class IOBuf; + class IOBufQueue; +} +namespace apache { namespace thrift { + class Cpp2RequestContext; + class BinaryProtocolReader; + class CompactProtocolReader; + namespace transport { class THeader; } +}} + +namespace nebula { namespace storage { namespace cpp2 { + +class StorageAdminServiceSvAsyncIf { + public: + virtual ~StorageAdminServiceSvAsyncIf() {} + virtual void async_tm_transLeader(std::unique_ptr> callback, const ::nebula::storage::cpp2::TransLeaderReq& p_req) = 0; + virtual folly::Future< ::nebula::storage::cpp2::AdminExecResp> future_transLeader(const ::nebula::storage::cpp2::TransLeaderReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::storage::cpp2::AdminExecResp> semifuture_transLeader(const ::nebula::storage::cpp2::TransLeaderReq& p_req) = 0; + virtual void async_tm_addPart(std::unique_ptr> callback, const ::nebula::storage::cpp2::AddPartReq& p_req) = 0; + virtual folly::Future< ::nebula::storage::cpp2::AdminExecResp> future_addPart(const ::nebula::storage::cpp2::AddPartReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::storage::cpp2::AdminExecResp> semifuture_addPart(const ::nebula::storage::cpp2::AddPartReq& p_req) = 0; + virtual void async_tm_addLearner(std::unique_ptr> callback, const ::nebula::storage::cpp2::AddLearnerReq& p_req) = 0; + virtual folly::Future< ::nebula::storage::cpp2::AdminExecResp> future_addLearner(const ::nebula::storage::cpp2::AddLearnerReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::storage::cpp2::AdminExecResp> semifuture_addLearner(const ::nebula::storage::cpp2::AddLearnerReq& p_req) = 0; + virtual void async_tm_removePart(std::unique_ptr> callback, const ::nebula::storage::cpp2::RemovePartReq& p_req) = 0; + virtual folly::Future< ::nebula::storage::cpp2::AdminExecResp> future_removePart(const ::nebula::storage::cpp2::RemovePartReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::storage::cpp2::AdminExecResp> semifuture_removePart(const ::nebula::storage::cpp2::RemovePartReq& p_req) = 0; + virtual void async_tm_memberChange(std::unique_ptr> callback, const ::nebula::storage::cpp2::MemberChangeReq& p_req) = 0; + virtual folly::Future< ::nebula::storage::cpp2::AdminExecResp> future_memberChange(const ::nebula::storage::cpp2::MemberChangeReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::storage::cpp2::AdminExecResp> semifuture_memberChange(const ::nebula::storage::cpp2::MemberChangeReq& p_req) = 0; + virtual void async_tm_waitingForCatchUpData(std::unique_ptr> callback, const ::nebula::storage::cpp2::CatchUpDataReq& p_req) = 0; + virtual folly::Future< ::nebula::storage::cpp2::AdminExecResp> future_waitingForCatchUpData(const ::nebula::storage::cpp2::CatchUpDataReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::storage::cpp2::AdminExecResp> semifuture_waitingForCatchUpData(const ::nebula::storage::cpp2::CatchUpDataReq& p_req) = 0; + virtual void async_tm_createCheckpoint(std::unique_ptr> callback, const ::nebula::storage::cpp2::CreateCPRequest& p_req) = 0; + virtual folly::Future< ::nebula::storage::cpp2::CreateCPResp> future_createCheckpoint(const ::nebula::storage::cpp2::CreateCPRequest& p_req) = 0; + virtual folly::SemiFuture< ::nebula::storage::cpp2::CreateCPResp> semifuture_createCheckpoint(const ::nebula::storage::cpp2::CreateCPRequest& p_req) = 0; + virtual void async_tm_dropCheckpoint(std::unique_ptr> callback, const ::nebula::storage::cpp2::DropCPRequest& p_req) = 0; + virtual folly::Future< ::nebula::storage::cpp2::AdminExecResp> future_dropCheckpoint(const ::nebula::storage::cpp2::DropCPRequest& p_req) = 0; + virtual folly::SemiFuture< ::nebula::storage::cpp2::AdminExecResp> semifuture_dropCheckpoint(const ::nebula::storage::cpp2::DropCPRequest& p_req) = 0; + virtual void async_tm_blockingWrites(std::unique_ptr> callback, const ::nebula::storage::cpp2::BlockingSignRequest& p_req) = 0; + virtual folly::Future< ::nebula::storage::cpp2::AdminExecResp> future_blockingWrites(const ::nebula::storage::cpp2::BlockingSignRequest& p_req) = 0; + virtual folly::SemiFuture< ::nebula::storage::cpp2::AdminExecResp> semifuture_blockingWrites(const ::nebula::storage::cpp2::BlockingSignRequest& p_req) = 0; + virtual void async_tm_rebuildTagIndex(std::unique_ptr> callback, const ::nebula::storage::cpp2::RebuildIndexRequest& p_req) = 0; + virtual folly::Future< ::nebula::storage::cpp2::AdminExecResp> future_rebuildTagIndex(const ::nebula::storage::cpp2::RebuildIndexRequest& p_req) = 0; + virtual folly::SemiFuture< ::nebula::storage::cpp2::AdminExecResp> semifuture_rebuildTagIndex(const ::nebula::storage::cpp2::RebuildIndexRequest& p_req) = 0; + virtual void async_tm_rebuildEdgeIndex(std::unique_ptr> callback, const ::nebula::storage::cpp2::RebuildIndexRequest& p_req) = 0; + virtual folly::Future< ::nebula::storage::cpp2::AdminExecResp> future_rebuildEdgeIndex(const ::nebula::storage::cpp2::RebuildIndexRequest& p_req) = 0; + virtual folly::SemiFuture< ::nebula::storage::cpp2::AdminExecResp> semifuture_rebuildEdgeIndex(const ::nebula::storage::cpp2::RebuildIndexRequest& p_req) = 0; + virtual void async_tm_getLeaderParts(std::unique_ptr> callback, const ::nebula::storage::cpp2::GetLeaderReq& p_req) = 0; + virtual folly::Future< ::nebula::storage::cpp2::GetLeaderPartsResp> future_getLeaderParts(const ::nebula::storage::cpp2::GetLeaderReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::storage::cpp2::GetLeaderPartsResp> semifuture_getLeaderParts(const ::nebula::storage::cpp2::GetLeaderReq& p_req) = 0; + virtual void async_tm_checkPeers(std::unique_ptr> callback, const ::nebula::storage::cpp2::CheckPeersReq& p_req) = 0; + virtual folly::Future< ::nebula::storage::cpp2::AdminExecResp> future_checkPeers(const ::nebula::storage::cpp2::CheckPeersReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::storage::cpp2::AdminExecResp> semifuture_checkPeers(const ::nebula::storage::cpp2::CheckPeersReq& p_req) = 0; + virtual void async_tm_addAdminTask(std::unique_ptr> callback, const ::nebula::storage::cpp2::AddAdminTaskRequest& p_req) = 0; + virtual folly::Future< ::nebula::storage::cpp2::AdminExecResp> future_addAdminTask(const ::nebula::storage::cpp2::AddAdminTaskRequest& p_req) = 0; + virtual folly::SemiFuture< ::nebula::storage::cpp2::AdminExecResp> semifuture_addAdminTask(const ::nebula::storage::cpp2::AddAdminTaskRequest& p_req) = 0; + virtual void async_tm_stopAdminTask(std::unique_ptr> callback, const ::nebula::storage::cpp2::StopAdminTaskRequest& p_req) = 0; + virtual folly::Future< ::nebula::storage::cpp2::AdminExecResp> future_stopAdminTask(const ::nebula::storage::cpp2::StopAdminTaskRequest& p_req) = 0; + virtual folly::SemiFuture< ::nebula::storage::cpp2::AdminExecResp> semifuture_stopAdminTask(const ::nebula::storage::cpp2::StopAdminTaskRequest& p_req) = 0; + virtual void async_tm_listClusterInfo(std::unique_ptr> callback, const ::nebula::storage::cpp2::ListClusterInfoReq& p_req) = 0; + virtual folly::Future< ::nebula::storage::cpp2::ListClusterInfoResp> future_listClusterInfo(const ::nebula::storage::cpp2::ListClusterInfoReq& p_req) = 0; + virtual folly::SemiFuture< ::nebula::storage::cpp2::ListClusterInfoResp> semifuture_listClusterInfo(const ::nebula::storage::cpp2::ListClusterInfoReq& p_req) = 0; +}; + +class StorageAdminServiceAsyncProcessor; + +class StorageAdminServiceSvIf : public StorageAdminServiceSvAsyncIf, public apache::thrift::ServerInterface { + public: + typedef StorageAdminServiceAsyncProcessor ProcessorType; + std::unique_ptr getProcessor() override; + + + virtual void transLeader( ::nebula::storage::cpp2::AdminExecResp& /*_return*/, const ::nebula::storage::cpp2::TransLeaderReq& /*req*/); + folly::Future< ::nebula::storage::cpp2::AdminExecResp> future_transLeader(const ::nebula::storage::cpp2::TransLeaderReq& p_req) override; + folly::SemiFuture< ::nebula::storage::cpp2::AdminExecResp> semifuture_transLeader(const ::nebula::storage::cpp2::TransLeaderReq& p_req) override; + void async_tm_transLeader(std::unique_ptr> callback, const ::nebula::storage::cpp2::TransLeaderReq& p_req) override; + virtual void addPart( ::nebula::storage::cpp2::AdminExecResp& /*_return*/, const ::nebula::storage::cpp2::AddPartReq& /*req*/); + folly::Future< ::nebula::storage::cpp2::AdminExecResp> future_addPart(const ::nebula::storage::cpp2::AddPartReq& p_req) override; + folly::SemiFuture< ::nebula::storage::cpp2::AdminExecResp> semifuture_addPart(const ::nebula::storage::cpp2::AddPartReq& p_req) override; + void async_tm_addPart(std::unique_ptr> callback, const ::nebula::storage::cpp2::AddPartReq& p_req) override; + virtual void addLearner( ::nebula::storage::cpp2::AdminExecResp& /*_return*/, const ::nebula::storage::cpp2::AddLearnerReq& /*req*/); + folly::Future< ::nebula::storage::cpp2::AdminExecResp> future_addLearner(const ::nebula::storage::cpp2::AddLearnerReq& p_req) override; + folly::SemiFuture< ::nebula::storage::cpp2::AdminExecResp> semifuture_addLearner(const ::nebula::storage::cpp2::AddLearnerReq& p_req) override; + void async_tm_addLearner(std::unique_ptr> callback, const ::nebula::storage::cpp2::AddLearnerReq& p_req) override; + virtual void removePart( ::nebula::storage::cpp2::AdminExecResp& /*_return*/, const ::nebula::storage::cpp2::RemovePartReq& /*req*/); + folly::Future< ::nebula::storage::cpp2::AdminExecResp> future_removePart(const ::nebula::storage::cpp2::RemovePartReq& p_req) override; + folly::SemiFuture< ::nebula::storage::cpp2::AdminExecResp> semifuture_removePart(const ::nebula::storage::cpp2::RemovePartReq& p_req) override; + void async_tm_removePart(std::unique_ptr> callback, const ::nebula::storage::cpp2::RemovePartReq& p_req) override; + virtual void memberChange( ::nebula::storage::cpp2::AdminExecResp& /*_return*/, const ::nebula::storage::cpp2::MemberChangeReq& /*req*/); + folly::Future< ::nebula::storage::cpp2::AdminExecResp> future_memberChange(const ::nebula::storage::cpp2::MemberChangeReq& p_req) override; + folly::SemiFuture< ::nebula::storage::cpp2::AdminExecResp> semifuture_memberChange(const ::nebula::storage::cpp2::MemberChangeReq& p_req) override; + void async_tm_memberChange(std::unique_ptr> callback, const ::nebula::storage::cpp2::MemberChangeReq& p_req) override; + virtual void waitingForCatchUpData( ::nebula::storage::cpp2::AdminExecResp& /*_return*/, const ::nebula::storage::cpp2::CatchUpDataReq& /*req*/); + folly::Future< ::nebula::storage::cpp2::AdminExecResp> future_waitingForCatchUpData(const ::nebula::storage::cpp2::CatchUpDataReq& p_req) override; + folly::SemiFuture< ::nebula::storage::cpp2::AdminExecResp> semifuture_waitingForCatchUpData(const ::nebula::storage::cpp2::CatchUpDataReq& p_req) override; + void async_tm_waitingForCatchUpData(std::unique_ptr> callback, const ::nebula::storage::cpp2::CatchUpDataReq& p_req) override; + virtual void createCheckpoint( ::nebula::storage::cpp2::CreateCPResp& /*_return*/, const ::nebula::storage::cpp2::CreateCPRequest& /*req*/); + folly::Future< ::nebula::storage::cpp2::CreateCPResp> future_createCheckpoint(const ::nebula::storage::cpp2::CreateCPRequest& p_req) override; + folly::SemiFuture< ::nebula::storage::cpp2::CreateCPResp> semifuture_createCheckpoint(const ::nebula::storage::cpp2::CreateCPRequest& p_req) override; + void async_tm_createCheckpoint(std::unique_ptr> callback, const ::nebula::storage::cpp2::CreateCPRequest& p_req) override; + virtual void dropCheckpoint( ::nebula::storage::cpp2::AdminExecResp& /*_return*/, const ::nebula::storage::cpp2::DropCPRequest& /*req*/); + folly::Future< ::nebula::storage::cpp2::AdminExecResp> future_dropCheckpoint(const ::nebula::storage::cpp2::DropCPRequest& p_req) override; + folly::SemiFuture< ::nebula::storage::cpp2::AdminExecResp> semifuture_dropCheckpoint(const ::nebula::storage::cpp2::DropCPRequest& p_req) override; + void async_tm_dropCheckpoint(std::unique_ptr> callback, const ::nebula::storage::cpp2::DropCPRequest& p_req) override; + virtual void blockingWrites( ::nebula::storage::cpp2::AdminExecResp& /*_return*/, const ::nebula::storage::cpp2::BlockingSignRequest& /*req*/); + folly::Future< ::nebula::storage::cpp2::AdminExecResp> future_blockingWrites(const ::nebula::storage::cpp2::BlockingSignRequest& p_req) override; + folly::SemiFuture< ::nebula::storage::cpp2::AdminExecResp> semifuture_blockingWrites(const ::nebula::storage::cpp2::BlockingSignRequest& p_req) override; + void async_tm_blockingWrites(std::unique_ptr> callback, const ::nebula::storage::cpp2::BlockingSignRequest& p_req) override; + virtual void rebuildTagIndex( ::nebula::storage::cpp2::AdminExecResp& /*_return*/, const ::nebula::storage::cpp2::RebuildIndexRequest& /*req*/); + folly::Future< ::nebula::storage::cpp2::AdminExecResp> future_rebuildTagIndex(const ::nebula::storage::cpp2::RebuildIndexRequest& p_req) override; + folly::SemiFuture< ::nebula::storage::cpp2::AdminExecResp> semifuture_rebuildTagIndex(const ::nebula::storage::cpp2::RebuildIndexRequest& p_req) override; + void async_tm_rebuildTagIndex(std::unique_ptr> callback, const ::nebula::storage::cpp2::RebuildIndexRequest& p_req) override; + virtual void rebuildEdgeIndex( ::nebula::storage::cpp2::AdminExecResp& /*_return*/, const ::nebula::storage::cpp2::RebuildIndexRequest& /*req*/); + folly::Future< ::nebula::storage::cpp2::AdminExecResp> future_rebuildEdgeIndex(const ::nebula::storage::cpp2::RebuildIndexRequest& p_req) override; + folly::SemiFuture< ::nebula::storage::cpp2::AdminExecResp> semifuture_rebuildEdgeIndex(const ::nebula::storage::cpp2::RebuildIndexRequest& p_req) override; + void async_tm_rebuildEdgeIndex(std::unique_ptr> callback, const ::nebula::storage::cpp2::RebuildIndexRequest& p_req) override; + virtual void getLeaderParts( ::nebula::storage::cpp2::GetLeaderPartsResp& /*_return*/, const ::nebula::storage::cpp2::GetLeaderReq& /*req*/); + folly::Future< ::nebula::storage::cpp2::GetLeaderPartsResp> future_getLeaderParts(const ::nebula::storage::cpp2::GetLeaderReq& p_req) override; + folly::SemiFuture< ::nebula::storage::cpp2::GetLeaderPartsResp> semifuture_getLeaderParts(const ::nebula::storage::cpp2::GetLeaderReq& p_req) override; + void async_tm_getLeaderParts(std::unique_ptr> callback, const ::nebula::storage::cpp2::GetLeaderReq& p_req) override; + virtual void checkPeers( ::nebula::storage::cpp2::AdminExecResp& /*_return*/, const ::nebula::storage::cpp2::CheckPeersReq& /*req*/); + folly::Future< ::nebula::storage::cpp2::AdminExecResp> future_checkPeers(const ::nebula::storage::cpp2::CheckPeersReq& p_req) override; + folly::SemiFuture< ::nebula::storage::cpp2::AdminExecResp> semifuture_checkPeers(const ::nebula::storage::cpp2::CheckPeersReq& p_req) override; + void async_tm_checkPeers(std::unique_ptr> callback, const ::nebula::storage::cpp2::CheckPeersReq& p_req) override; + virtual void addAdminTask( ::nebula::storage::cpp2::AdminExecResp& /*_return*/, const ::nebula::storage::cpp2::AddAdminTaskRequest& /*req*/); + folly::Future< ::nebula::storage::cpp2::AdminExecResp> future_addAdminTask(const ::nebula::storage::cpp2::AddAdminTaskRequest& p_req) override; + folly::SemiFuture< ::nebula::storage::cpp2::AdminExecResp> semifuture_addAdminTask(const ::nebula::storage::cpp2::AddAdminTaskRequest& p_req) override; + void async_tm_addAdminTask(std::unique_ptr> callback, const ::nebula::storage::cpp2::AddAdminTaskRequest& p_req) override; + virtual void stopAdminTask( ::nebula::storage::cpp2::AdminExecResp& /*_return*/, const ::nebula::storage::cpp2::StopAdminTaskRequest& /*req*/); + folly::Future< ::nebula::storage::cpp2::AdminExecResp> future_stopAdminTask(const ::nebula::storage::cpp2::StopAdminTaskRequest& p_req) override; + folly::SemiFuture< ::nebula::storage::cpp2::AdminExecResp> semifuture_stopAdminTask(const ::nebula::storage::cpp2::StopAdminTaskRequest& p_req) override; + void async_tm_stopAdminTask(std::unique_ptr> callback, const ::nebula::storage::cpp2::StopAdminTaskRequest& p_req) override; + virtual void listClusterInfo( ::nebula::storage::cpp2::ListClusterInfoResp& /*_return*/, const ::nebula::storage::cpp2::ListClusterInfoReq& /*req*/); + folly::Future< ::nebula::storage::cpp2::ListClusterInfoResp> future_listClusterInfo(const ::nebula::storage::cpp2::ListClusterInfoReq& p_req) override; + folly::SemiFuture< ::nebula::storage::cpp2::ListClusterInfoResp> semifuture_listClusterInfo(const ::nebula::storage::cpp2::ListClusterInfoReq& p_req) override; + void async_tm_listClusterInfo(std::unique_ptr> callback, const ::nebula::storage::cpp2::ListClusterInfoReq& p_req) override; +}; + +class StorageAdminServiceSvNull : public StorageAdminServiceSvIf { + public: + void transLeader( ::nebula::storage::cpp2::AdminExecResp& /*_return*/, const ::nebula::storage::cpp2::TransLeaderReq& /*req*/) override; + void addPart( ::nebula::storage::cpp2::AdminExecResp& /*_return*/, const ::nebula::storage::cpp2::AddPartReq& /*req*/) override; + void addLearner( ::nebula::storage::cpp2::AdminExecResp& /*_return*/, const ::nebula::storage::cpp2::AddLearnerReq& /*req*/) override; + void removePart( ::nebula::storage::cpp2::AdminExecResp& /*_return*/, const ::nebula::storage::cpp2::RemovePartReq& /*req*/) override; + void memberChange( ::nebula::storage::cpp2::AdminExecResp& /*_return*/, const ::nebula::storage::cpp2::MemberChangeReq& /*req*/) override; + void waitingForCatchUpData( ::nebula::storage::cpp2::AdminExecResp& /*_return*/, const ::nebula::storage::cpp2::CatchUpDataReq& /*req*/) override; + void createCheckpoint( ::nebula::storage::cpp2::CreateCPResp& /*_return*/, const ::nebula::storage::cpp2::CreateCPRequest& /*req*/) override; + void dropCheckpoint( ::nebula::storage::cpp2::AdminExecResp& /*_return*/, const ::nebula::storage::cpp2::DropCPRequest& /*req*/) override; + void blockingWrites( ::nebula::storage::cpp2::AdminExecResp& /*_return*/, const ::nebula::storage::cpp2::BlockingSignRequest& /*req*/) override; + void rebuildTagIndex( ::nebula::storage::cpp2::AdminExecResp& /*_return*/, const ::nebula::storage::cpp2::RebuildIndexRequest& /*req*/) override; + void rebuildEdgeIndex( ::nebula::storage::cpp2::AdminExecResp& /*_return*/, const ::nebula::storage::cpp2::RebuildIndexRequest& /*req*/) override; + void getLeaderParts( ::nebula::storage::cpp2::GetLeaderPartsResp& /*_return*/, const ::nebula::storage::cpp2::GetLeaderReq& /*req*/) override; + void checkPeers( ::nebula::storage::cpp2::AdminExecResp& /*_return*/, const ::nebula::storage::cpp2::CheckPeersReq& /*req*/) override; + void addAdminTask( ::nebula::storage::cpp2::AdminExecResp& /*_return*/, const ::nebula::storage::cpp2::AddAdminTaskRequest& /*req*/) override; + void stopAdminTask( ::nebula::storage::cpp2::AdminExecResp& /*_return*/, const ::nebula::storage::cpp2::StopAdminTaskRequest& /*req*/) override; + void listClusterInfo( ::nebula::storage::cpp2::ListClusterInfoResp& /*_return*/, const ::nebula::storage::cpp2::ListClusterInfoReq& /*req*/) override; +}; + +class StorageAdminServiceAsyncProcessor : public ::apache::thrift::GeneratedAsyncProcessor { + public: + const char* getServiceName() override; + void getServiceMetadata(apache::thrift::metadata::ThriftServiceMetadataResponse& response) override; + using BaseAsyncProcessor = void; + protected: + StorageAdminServiceSvIf* iface_; + public: + void processSerializedRequest(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::protocol::PROTOCOL_TYPES protType, apache::thrift::Cpp2RequestContext* context, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) override; + protected: + std::shared_ptr getBaseContextForRequest() override; + public: + using ProcessFunc = GeneratedAsyncProcessor::ProcessFunc; + using ProcessMap = GeneratedAsyncProcessor::ProcessMap; + static const StorageAdminServiceAsyncProcessor::ProcessMap& getBinaryProtocolProcessMap(); + static const StorageAdminServiceAsyncProcessor::ProcessMap& getCompactProtocolProcessMap(); + private: + static const StorageAdminServiceAsyncProcessor::ProcessMap binaryProcessMap_; + static const StorageAdminServiceAsyncProcessor::ProcessMap compactProcessMap_; + private: + template + void setUpAndProcess_transLeader(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_transLeader(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_transLeader(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::storage::cpp2::AdminExecResp const& _return); + template + static void throw_wrapped_transLeader(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_addPart(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_addPart(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_addPart(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::storage::cpp2::AdminExecResp const& _return); + template + static void throw_wrapped_addPart(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_addLearner(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_addLearner(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_addLearner(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::storage::cpp2::AdminExecResp const& _return); + template + static void throw_wrapped_addLearner(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_removePart(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_removePart(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_removePart(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::storage::cpp2::AdminExecResp const& _return); + template + static void throw_wrapped_removePart(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_memberChange(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_memberChange(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_memberChange(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::storage::cpp2::AdminExecResp const& _return); + template + static void throw_wrapped_memberChange(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_waitingForCatchUpData(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_waitingForCatchUpData(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_waitingForCatchUpData(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::storage::cpp2::AdminExecResp const& _return); + template + static void throw_wrapped_waitingForCatchUpData(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_createCheckpoint(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_createCheckpoint(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_createCheckpoint(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::storage::cpp2::CreateCPResp const& _return); + template + static void throw_wrapped_createCheckpoint(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_dropCheckpoint(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_dropCheckpoint(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_dropCheckpoint(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::storage::cpp2::AdminExecResp const& _return); + template + static void throw_wrapped_dropCheckpoint(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_blockingWrites(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_blockingWrites(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_blockingWrites(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::storage::cpp2::AdminExecResp const& _return); + template + static void throw_wrapped_blockingWrites(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_rebuildTagIndex(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_rebuildTagIndex(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_rebuildTagIndex(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::storage::cpp2::AdminExecResp const& _return); + template + static void throw_wrapped_rebuildTagIndex(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_rebuildEdgeIndex(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_rebuildEdgeIndex(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_rebuildEdgeIndex(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::storage::cpp2::AdminExecResp const& _return); + template + static void throw_wrapped_rebuildEdgeIndex(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_getLeaderParts(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_getLeaderParts(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_getLeaderParts(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::storage::cpp2::GetLeaderPartsResp const& _return); + template + static void throw_wrapped_getLeaderParts(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_checkPeers(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_checkPeers(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_checkPeers(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::storage::cpp2::AdminExecResp const& _return); + template + static void throw_wrapped_checkPeers(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_addAdminTask(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_addAdminTask(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_addAdminTask(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::storage::cpp2::AdminExecResp const& _return); + template + static void throw_wrapped_addAdminTask(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_stopAdminTask(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_stopAdminTask(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_stopAdminTask(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::storage::cpp2::AdminExecResp const& _return); + template + static void throw_wrapped_stopAdminTask(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + template + void setUpAndProcess_listClusterInfo(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + void process_listClusterInfo(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx,folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm); + template + static folly::IOBufQueue return_listClusterInfo(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::storage::cpp2::ListClusterInfoResp const& _return); + template + static void throw_wrapped_listClusterInfo(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx); + public: + StorageAdminServiceAsyncProcessor(StorageAdminServiceSvIf* iface) : + iface_(iface) {} + + virtual ~StorageAdminServiceAsyncProcessor() {} +}; + +}}} // nebula::storage::cpp2 diff --git a/src/interface/gen-cpp2/StorageAdminService.tcc b/src/interface/gen-cpp2/StorageAdminService.tcc new file mode 100644 index 00000000..95dddf9f --- /dev/null +++ b/src/interface/gen-cpp2/StorageAdminService.tcc @@ -0,0 +1,959 @@ +/** + * Autogenerated by Thrift for storage.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#pragma once + +#include "StorageAdminService.h" + +#include + +namespace nebula { namespace storage { namespace cpp2 { +typedef apache::thrift::ThriftPresult> StorageAdminService_transLeader_pargs; +typedef apache::thrift::ThriftPresult> StorageAdminService_transLeader_presult; +typedef apache::thrift::ThriftPresult> StorageAdminService_addPart_pargs; +typedef apache::thrift::ThriftPresult> StorageAdminService_addPart_presult; +typedef apache::thrift::ThriftPresult> StorageAdminService_addLearner_pargs; +typedef apache::thrift::ThriftPresult> StorageAdminService_addLearner_presult; +typedef apache::thrift::ThriftPresult> StorageAdminService_removePart_pargs; +typedef apache::thrift::ThriftPresult> StorageAdminService_removePart_presult; +typedef apache::thrift::ThriftPresult> StorageAdminService_memberChange_pargs; +typedef apache::thrift::ThriftPresult> StorageAdminService_memberChange_presult; +typedef apache::thrift::ThriftPresult> StorageAdminService_waitingForCatchUpData_pargs; +typedef apache::thrift::ThriftPresult> StorageAdminService_waitingForCatchUpData_presult; +typedef apache::thrift::ThriftPresult> StorageAdminService_createCheckpoint_pargs; +typedef apache::thrift::ThriftPresult> StorageAdminService_createCheckpoint_presult; +typedef apache::thrift::ThriftPresult> StorageAdminService_dropCheckpoint_pargs; +typedef apache::thrift::ThriftPresult> StorageAdminService_dropCheckpoint_presult; +typedef apache::thrift::ThriftPresult> StorageAdminService_blockingWrites_pargs; +typedef apache::thrift::ThriftPresult> StorageAdminService_blockingWrites_presult; +typedef apache::thrift::ThriftPresult> StorageAdminService_rebuildTagIndex_pargs; +typedef apache::thrift::ThriftPresult> StorageAdminService_rebuildTagIndex_presult; +typedef apache::thrift::ThriftPresult> StorageAdminService_rebuildEdgeIndex_pargs; +typedef apache::thrift::ThriftPresult> StorageAdminService_rebuildEdgeIndex_presult; +typedef apache::thrift::ThriftPresult> StorageAdminService_getLeaderParts_pargs; +typedef apache::thrift::ThriftPresult> StorageAdminService_getLeaderParts_presult; +typedef apache::thrift::ThriftPresult> StorageAdminService_checkPeers_pargs; +typedef apache::thrift::ThriftPresult> StorageAdminService_checkPeers_presult; +typedef apache::thrift::ThriftPresult> StorageAdminService_addAdminTask_pargs; +typedef apache::thrift::ThriftPresult> StorageAdminService_addAdminTask_presult; +typedef apache::thrift::ThriftPresult> StorageAdminService_stopAdminTask_pargs; +typedef apache::thrift::ThriftPresult> StorageAdminService_stopAdminTask_presult; +typedef apache::thrift::ThriftPresult> StorageAdminService_listClusterInfo_pargs; +typedef apache::thrift::ThriftPresult> StorageAdminService_listClusterInfo_presult; +template +void StorageAdminServiceAsyncProcessor::setUpAndProcess_transLeader(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &StorageAdminServiceAsyncProcessor::process_transLeader, this); +} + +template +void StorageAdminServiceAsyncProcessor::process_transLeader(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + StorageAdminService_transLeader_pargs args; + ::nebula::storage::cpp2::TransLeaderReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "StorageAdminService.transLeader", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "transLeader"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_transLeader, throw_wrapped_transLeader, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_transLeader(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue StorageAdminServiceAsyncProcessor::return_transLeader(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::storage::cpp2::AdminExecResp const& _return) { + ProtocolOut_ prot; + StorageAdminService_transLeader_presult result; + result.get<0>().value = const_cast< ::nebula::storage::cpp2::AdminExecResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("transLeader", &prot, protoSeqId, ctx, result); +} + +template +void StorageAdminServiceAsyncProcessor::throw_wrapped_transLeader(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "transLeader"); + return; + } +} + +template +void StorageAdminServiceAsyncProcessor::setUpAndProcess_addPart(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &StorageAdminServiceAsyncProcessor::process_addPart, this); +} + +template +void StorageAdminServiceAsyncProcessor::process_addPart(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + StorageAdminService_addPart_pargs args; + ::nebula::storage::cpp2::AddPartReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "StorageAdminService.addPart", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "addPart"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_addPart, throw_wrapped_addPart, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_addPart(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue StorageAdminServiceAsyncProcessor::return_addPart(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::storage::cpp2::AdminExecResp const& _return) { + ProtocolOut_ prot; + StorageAdminService_addPart_presult result; + result.get<0>().value = const_cast< ::nebula::storage::cpp2::AdminExecResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("addPart", &prot, protoSeqId, ctx, result); +} + +template +void StorageAdminServiceAsyncProcessor::throw_wrapped_addPart(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "addPart"); + return; + } +} + +template +void StorageAdminServiceAsyncProcessor::setUpAndProcess_addLearner(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &StorageAdminServiceAsyncProcessor::process_addLearner, this); +} + +template +void StorageAdminServiceAsyncProcessor::process_addLearner(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + StorageAdminService_addLearner_pargs args; + ::nebula::storage::cpp2::AddLearnerReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "StorageAdminService.addLearner", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "addLearner"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_addLearner, throw_wrapped_addLearner, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_addLearner(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue StorageAdminServiceAsyncProcessor::return_addLearner(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::storage::cpp2::AdminExecResp const& _return) { + ProtocolOut_ prot; + StorageAdminService_addLearner_presult result; + result.get<0>().value = const_cast< ::nebula::storage::cpp2::AdminExecResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("addLearner", &prot, protoSeqId, ctx, result); +} + +template +void StorageAdminServiceAsyncProcessor::throw_wrapped_addLearner(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "addLearner"); + return; + } +} + +template +void StorageAdminServiceAsyncProcessor::setUpAndProcess_removePart(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &StorageAdminServiceAsyncProcessor::process_removePart, this); +} + +template +void StorageAdminServiceAsyncProcessor::process_removePart(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + StorageAdminService_removePart_pargs args; + ::nebula::storage::cpp2::RemovePartReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "StorageAdminService.removePart", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "removePart"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_removePart, throw_wrapped_removePart, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_removePart(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue StorageAdminServiceAsyncProcessor::return_removePart(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::storage::cpp2::AdminExecResp const& _return) { + ProtocolOut_ prot; + StorageAdminService_removePart_presult result; + result.get<0>().value = const_cast< ::nebula::storage::cpp2::AdminExecResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("removePart", &prot, protoSeqId, ctx, result); +} + +template +void StorageAdminServiceAsyncProcessor::throw_wrapped_removePart(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "removePart"); + return; + } +} + +template +void StorageAdminServiceAsyncProcessor::setUpAndProcess_memberChange(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &StorageAdminServiceAsyncProcessor::process_memberChange, this); +} + +template +void StorageAdminServiceAsyncProcessor::process_memberChange(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + StorageAdminService_memberChange_pargs args; + ::nebula::storage::cpp2::MemberChangeReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "StorageAdminService.memberChange", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "memberChange"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_memberChange, throw_wrapped_memberChange, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_memberChange(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue StorageAdminServiceAsyncProcessor::return_memberChange(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::storage::cpp2::AdminExecResp const& _return) { + ProtocolOut_ prot; + StorageAdminService_memberChange_presult result; + result.get<0>().value = const_cast< ::nebula::storage::cpp2::AdminExecResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("memberChange", &prot, protoSeqId, ctx, result); +} + +template +void StorageAdminServiceAsyncProcessor::throw_wrapped_memberChange(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "memberChange"); + return; + } +} + +template +void StorageAdminServiceAsyncProcessor::setUpAndProcess_waitingForCatchUpData(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &StorageAdminServiceAsyncProcessor::process_waitingForCatchUpData, this); +} + +template +void StorageAdminServiceAsyncProcessor::process_waitingForCatchUpData(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + StorageAdminService_waitingForCatchUpData_pargs args; + ::nebula::storage::cpp2::CatchUpDataReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "StorageAdminService.waitingForCatchUpData", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "waitingForCatchUpData"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_waitingForCatchUpData, throw_wrapped_waitingForCatchUpData, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_waitingForCatchUpData(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue StorageAdminServiceAsyncProcessor::return_waitingForCatchUpData(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::storage::cpp2::AdminExecResp const& _return) { + ProtocolOut_ prot; + StorageAdminService_waitingForCatchUpData_presult result; + result.get<0>().value = const_cast< ::nebula::storage::cpp2::AdminExecResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("waitingForCatchUpData", &prot, protoSeqId, ctx, result); +} + +template +void StorageAdminServiceAsyncProcessor::throw_wrapped_waitingForCatchUpData(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "waitingForCatchUpData"); + return; + } +} + +template +void StorageAdminServiceAsyncProcessor::setUpAndProcess_createCheckpoint(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &StorageAdminServiceAsyncProcessor::process_createCheckpoint, this); +} + +template +void StorageAdminServiceAsyncProcessor::process_createCheckpoint(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + StorageAdminService_createCheckpoint_pargs args; + ::nebula::storage::cpp2::CreateCPRequest uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "StorageAdminService.createCheckpoint", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "createCheckpoint"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_createCheckpoint, throw_wrapped_createCheckpoint, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_createCheckpoint(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue StorageAdminServiceAsyncProcessor::return_createCheckpoint(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::storage::cpp2::CreateCPResp const& _return) { + ProtocolOut_ prot; + StorageAdminService_createCheckpoint_presult result; + result.get<0>().value = const_cast< ::nebula::storage::cpp2::CreateCPResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("createCheckpoint", &prot, protoSeqId, ctx, result); +} + +template +void StorageAdminServiceAsyncProcessor::throw_wrapped_createCheckpoint(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "createCheckpoint"); + return; + } +} + +template +void StorageAdminServiceAsyncProcessor::setUpAndProcess_dropCheckpoint(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &StorageAdminServiceAsyncProcessor::process_dropCheckpoint, this); +} + +template +void StorageAdminServiceAsyncProcessor::process_dropCheckpoint(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + StorageAdminService_dropCheckpoint_pargs args; + ::nebula::storage::cpp2::DropCPRequest uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "StorageAdminService.dropCheckpoint", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "dropCheckpoint"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_dropCheckpoint, throw_wrapped_dropCheckpoint, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_dropCheckpoint(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue StorageAdminServiceAsyncProcessor::return_dropCheckpoint(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::storage::cpp2::AdminExecResp const& _return) { + ProtocolOut_ prot; + StorageAdminService_dropCheckpoint_presult result; + result.get<0>().value = const_cast< ::nebula::storage::cpp2::AdminExecResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("dropCheckpoint", &prot, protoSeqId, ctx, result); +} + +template +void StorageAdminServiceAsyncProcessor::throw_wrapped_dropCheckpoint(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "dropCheckpoint"); + return; + } +} + +template +void StorageAdminServiceAsyncProcessor::setUpAndProcess_blockingWrites(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &StorageAdminServiceAsyncProcessor::process_blockingWrites, this); +} + +template +void StorageAdminServiceAsyncProcessor::process_blockingWrites(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + StorageAdminService_blockingWrites_pargs args; + ::nebula::storage::cpp2::BlockingSignRequest uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "StorageAdminService.blockingWrites", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "blockingWrites"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_blockingWrites, throw_wrapped_blockingWrites, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_blockingWrites(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue StorageAdminServiceAsyncProcessor::return_blockingWrites(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::storage::cpp2::AdminExecResp const& _return) { + ProtocolOut_ prot; + StorageAdminService_blockingWrites_presult result; + result.get<0>().value = const_cast< ::nebula::storage::cpp2::AdminExecResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("blockingWrites", &prot, protoSeqId, ctx, result); +} + +template +void StorageAdminServiceAsyncProcessor::throw_wrapped_blockingWrites(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "blockingWrites"); + return; + } +} + +template +void StorageAdminServiceAsyncProcessor::setUpAndProcess_rebuildTagIndex(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &StorageAdminServiceAsyncProcessor::process_rebuildTagIndex, this); +} + +template +void StorageAdminServiceAsyncProcessor::process_rebuildTagIndex(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + StorageAdminService_rebuildTagIndex_pargs args; + ::nebula::storage::cpp2::RebuildIndexRequest uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "StorageAdminService.rebuildTagIndex", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "rebuildTagIndex"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_rebuildTagIndex, throw_wrapped_rebuildTagIndex, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_rebuildTagIndex(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue StorageAdminServiceAsyncProcessor::return_rebuildTagIndex(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::storage::cpp2::AdminExecResp const& _return) { + ProtocolOut_ prot; + StorageAdminService_rebuildTagIndex_presult result; + result.get<0>().value = const_cast< ::nebula::storage::cpp2::AdminExecResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("rebuildTagIndex", &prot, protoSeqId, ctx, result); +} + +template +void StorageAdminServiceAsyncProcessor::throw_wrapped_rebuildTagIndex(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "rebuildTagIndex"); + return; + } +} + +template +void StorageAdminServiceAsyncProcessor::setUpAndProcess_rebuildEdgeIndex(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &StorageAdminServiceAsyncProcessor::process_rebuildEdgeIndex, this); +} + +template +void StorageAdminServiceAsyncProcessor::process_rebuildEdgeIndex(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + StorageAdminService_rebuildEdgeIndex_pargs args; + ::nebula::storage::cpp2::RebuildIndexRequest uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "StorageAdminService.rebuildEdgeIndex", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "rebuildEdgeIndex"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_rebuildEdgeIndex, throw_wrapped_rebuildEdgeIndex, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_rebuildEdgeIndex(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue StorageAdminServiceAsyncProcessor::return_rebuildEdgeIndex(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::storage::cpp2::AdminExecResp const& _return) { + ProtocolOut_ prot; + StorageAdminService_rebuildEdgeIndex_presult result; + result.get<0>().value = const_cast< ::nebula::storage::cpp2::AdminExecResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("rebuildEdgeIndex", &prot, protoSeqId, ctx, result); +} + +template +void StorageAdminServiceAsyncProcessor::throw_wrapped_rebuildEdgeIndex(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "rebuildEdgeIndex"); + return; + } +} + +template +void StorageAdminServiceAsyncProcessor::setUpAndProcess_getLeaderParts(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &StorageAdminServiceAsyncProcessor::process_getLeaderParts, this); +} + +template +void StorageAdminServiceAsyncProcessor::process_getLeaderParts(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + StorageAdminService_getLeaderParts_pargs args; + ::nebula::storage::cpp2::GetLeaderReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "StorageAdminService.getLeaderParts", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "getLeaderParts"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_getLeaderParts, throw_wrapped_getLeaderParts, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_getLeaderParts(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue StorageAdminServiceAsyncProcessor::return_getLeaderParts(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::storage::cpp2::GetLeaderPartsResp const& _return) { + ProtocolOut_ prot; + StorageAdminService_getLeaderParts_presult result; + result.get<0>().value = const_cast< ::nebula::storage::cpp2::GetLeaderPartsResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("getLeaderParts", &prot, protoSeqId, ctx, result); +} + +template +void StorageAdminServiceAsyncProcessor::throw_wrapped_getLeaderParts(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "getLeaderParts"); + return; + } +} + +template +void StorageAdminServiceAsyncProcessor::setUpAndProcess_checkPeers(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &StorageAdminServiceAsyncProcessor::process_checkPeers, this); +} + +template +void StorageAdminServiceAsyncProcessor::process_checkPeers(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + StorageAdminService_checkPeers_pargs args; + ::nebula::storage::cpp2::CheckPeersReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "StorageAdminService.checkPeers", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "checkPeers"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_checkPeers, throw_wrapped_checkPeers, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_checkPeers(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue StorageAdminServiceAsyncProcessor::return_checkPeers(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::storage::cpp2::AdminExecResp const& _return) { + ProtocolOut_ prot; + StorageAdminService_checkPeers_presult result; + result.get<0>().value = const_cast< ::nebula::storage::cpp2::AdminExecResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("checkPeers", &prot, protoSeqId, ctx, result); +} + +template +void StorageAdminServiceAsyncProcessor::throw_wrapped_checkPeers(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "checkPeers"); + return; + } +} + +template +void StorageAdminServiceAsyncProcessor::setUpAndProcess_addAdminTask(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &StorageAdminServiceAsyncProcessor::process_addAdminTask, this); +} + +template +void StorageAdminServiceAsyncProcessor::process_addAdminTask(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + StorageAdminService_addAdminTask_pargs args; + ::nebula::storage::cpp2::AddAdminTaskRequest uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "StorageAdminService.addAdminTask", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "addAdminTask"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_addAdminTask, throw_wrapped_addAdminTask, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_addAdminTask(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue StorageAdminServiceAsyncProcessor::return_addAdminTask(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::storage::cpp2::AdminExecResp const& _return) { + ProtocolOut_ prot; + StorageAdminService_addAdminTask_presult result; + result.get<0>().value = const_cast< ::nebula::storage::cpp2::AdminExecResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("addAdminTask", &prot, protoSeqId, ctx, result); +} + +template +void StorageAdminServiceAsyncProcessor::throw_wrapped_addAdminTask(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "addAdminTask"); + return; + } +} + +template +void StorageAdminServiceAsyncProcessor::setUpAndProcess_stopAdminTask(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &StorageAdminServiceAsyncProcessor::process_stopAdminTask, this); +} + +template +void StorageAdminServiceAsyncProcessor::process_stopAdminTask(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + StorageAdminService_stopAdminTask_pargs args; + ::nebula::storage::cpp2::StopAdminTaskRequest uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "StorageAdminService.stopAdminTask", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "stopAdminTask"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_stopAdminTask, throw_wrapped_stopAdminTask, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_stopAdminTask(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue StorageAdminServiceAsyncProcessor::return_stopAdminTask(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::storage::cpp2::AdminExecResp const& _return) { + ProtocolOut_ prot; + StorageAdminService_stopAdminTask_presult result; + result.get<0>().value = const_cast< ::nebula::storage::cpp2::AdminExecResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("stopAdminTask", &prot, protoSeqId, ctx, result); +} + +template +void StorageAdminServiceAsyncProcessor::throw_wrapped_stopAdminTask(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "stopAdminTask"); + return; + } +} + +template +void StorageAdminServiceAsyncProcessor::setUpAndProcess_listClusterInfo(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + if (!setUpRequestProcessing(req, ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, iface_)) { + return; + } + auto scope = iface_->getRequestExecutionScope(ctx, apache::thrift::concurrency::NORMAL); + ctx->setRequestExecutionScope(std::move(scope)); + processInThread(std::move(req), std::move(serializedRequest), ctx, eb, tm, apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, &StorageAdminServiceAsyncProcessor::process_listClusterInfo, this); +} + +template +void StorageAdminServiceAsyncProcessor::process_listClusterInfo(apache::thrift::ResponseChannelRequest::UniquePtr req, apache::thrift::SerializedRequest&& serializedRequest, apache::thrift::Cpp2RequestContext* ctx, folly::EventBase* eb, apache::thrift::concurrency::ThreadManager* tm) { + // make sure getRequestContext is null + // so async calls don't accidentally use it + iface_->setRequestContext(nullptr); + StorageAdminService_listClusterInfo_pargs args; + ::nebula::storage::cpp2::ListClusterInfoReq uarg_req; + args.get<0>().value = &uarg_req; + std::unique_ptr ctxStack(this->getContextStack(this->getServiceName(), "StorageAdminService.listClusterInfo", ctx)); + try { + deserializeRequest(args, ctx->getMethodName(), serializedRequest, ctxStack.get()); + } + catch (const std::exception& ex) { + apache::thrift::detail::ap::process_handle_exn_deserialization( + ex, std::move(req), ctx, eb, "listClusterInfo"); + return; + } + req->setStartedProcessing(); + auto callback = std::make_unique>(std::move(req), std::move(ctxStack), return_listClusterInfo, throw_wrapped_listClusterInfo, ctx->getProtoSeqId(), eb, tm, ctx); + if (!callback->isRequestActive()) { + return; + } + iface_->async_tm_listClusterInfo(std::move(callback), args.get<0>().ref()); +} + +template +folly::IOBufQueue StorageAdminServiceAsyncProcessor::return_listClusterInfo(int32_t protoSeqId, apache::thrift::ContextStack* ctx, ::nebula::storage::cpp2::ListClusterInfoResp const& _return) { + ProtocolOut_ prot; + StorageAdminService_listClusterInfo_presult result; + result.get<0>().value = const_cast< ::nebula::storage::cpp2::ListClusterInfoResp*>(&_return); + result.setIsSet(0, true); + return serializeResponse("listClusterInfo", &prot, protoSeqId, ctx, result); +} + +template +void StorageAdminServiceAsyncProcessor::throw_wrapped_listClusterInfo(apache::thrift::ResponseChannelRequest::UniquePtr req,int32_t protoSeqId,apache::thrift::ContextStack* ctx,folly::exception_wrapper ew,apache::thrift::Cpp2RequestContext* reqCtx) { + if (!ew) { + return; + } + { + (void)protoSeqId; + apache::thrift::detail::ap::process_throw_wrapped_handler_error( + ew, std::move(req), reqCtx, ctx, "listClusterInfo"); + return; + } +} + + +}}} // nebula::storage::cpp2 diff --git a/src/interface/gen-cpp2/StorageAdminServiceAsyncClient.cpp b/src/interface/gen-cpp2/StorageAdminServiceAsyncClient.cpp new file mode 100644 index 00000000..396aabeb --- /dev/null +++ b/src/interface/gen-cpp2/StorageAdminServiceAsyncClient.cpp @@ -0,0 +1,2929 @@ +/** + * Autogenerated by Thrift for storage.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ + +#include "StorageAdminServiceAsyncClient.h" + +#include + +namespace nebula { namespace storage { namespace cpp2 { +typedef apache::thrift::ThriftPresult> StorageAdminService_transLeader_pargs; +typedef apache::thrift::ThriftPresult> StorageAdminService_transLeader_presult; +typedef apache::thrift::ThriftPresult> StorageAdminService_addPart_pargs; +typedef apache::thrift::ThriftPresult> StorageAdminService_addPart_presult; +typedef apache::thrift::ThriftPresult> StorageAdminService_addLearner_pargs; +typedef apache::thrift::ThriftPresult> StorageAdminService_addLearner_presult; +typedef apache::thrift::ThriftPresult> StorageAdminService_removePart_pargs; +typedef apache::thrift::ThriftPresult> StorageAdminService_removePart_presult; +typedef apache::thrift::ThriftPresult> StorageAdminService_memberChange_pargs; +typedef apache::thrift::ThriftPresult> StorageAdminService_memberChange_presult; +typedef apache::thrift::ThriftPresult> StorageAdminService_waitingForCatchUpData_pargs; +typedef apache::thrift::ThriftPresult> StorageAdminService_waitingForCatchUpData_presult; +typedef apache::thrift::ThriftPresult> StorageAdminService_createCheckpoint_pargs; +typedef apache::thrift::ThriftPresult> StorageAdminService_createCheckpoint_presult; +typedef apache::thrift::ThriftPresult> StorageAdminService_dropCheckpoint_pargs; +typedef apache::thrift::ThriftPresult> StorageAdminService_dropCheckpoint_presult; +typedef apache::thrift::ThriftPresult> StorageAdminService_blockingWrites_pargs; +typedef apache::thrift::ThriftPresult> StorageAdminService_blockingWrites_presult; +typedef apache::thrift::ThriftPresult> StorageAdminService_rebuildTagIndex_pargs; +typedef apache::thrift::ThriftPresult> StorageAdminService_rebuildTagIndex_presult; +typedef apache::thrift::ThriftPresult> StorageAdminService_rebuildEdgeIndex_pargs; +typedef apache::thrift::ThriftPresult> StorageAdminService_rebuildEdgeIndex_presult; +typedef apache::thrift::ThriftPresult> StorageAdminService_getLeaderParts_pargs; +typedef apache::thrift::ThriftPresult> StorageAdminService_getLeaderParts_presult; +typedef apache::thrift::ThriftPresult> StorageAdminService_checkPeers_pargs; +typedef apache::thrift::ThriftPresult> StorageAdminService_checkPeers_presult; +typedef apache::thrift::ThriftPresult> StorageAdminService_addAdminTask_pargs; +typedef apache::thrift::ThriftPresult> StorageAdminService_addAdminTask_presult; +typedef apache::thrift::ThriftPresult> StorageAdminService_stopAdminTask_pargs; +typedef apache::thrift::ThriftPresult> StorageAdminService_stopAdminTask_presult; +typedef apache::thrift::ThriftPresult> StorageAdminService_listClusterInfo_pargs; +typedef apache::thrift::ThriftPresult> StorageAdminService_listClusterInfo_presult; + +template +void StorageAdminServiceAsyncClient::transLeaderT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::TransLeaderReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + StorageAdminService_transLeader_pargs args; + args.get<0>().value = const_cast< ::nebula::storage::cpp2::TransLeaderReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "transLeader"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void StorageAdminServiceAsyncClient::addPartT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::AddPartReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + StorageAdminService_addPart_pargs args; + args.get<0>().value = const_cast< ::nebula::storage::cpp2::AddPartReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "addPart"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void StorageAdminServiceAsyncClient::addLearnerT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::AddLearnerReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + StorageAdminService_addLearner_pargs args; + args.get<0>().value = const_cast< ::nebula::storage::cpp2::AddLearnerReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "addLearner"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void StorageAdminServiceAsyncClient::removePartT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::RemovePartReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + StorageAdminService_removePart_pargs args; + args.get<0>().value = const_cast< ::nebula::storage::cpp2::RemovePartReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "removePart"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void StorageAdminServiceAsyncClient::memberChangeT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::MemberChangeReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + StorageAdminService_memberChange_pargs args; + args.get<0>().value = const_cast< ::nebula::storage::cpp2::MemberChangeReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "memberChange"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void StorageAdminServiceAsyncClient::waitingForCatchUpDataT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::CatchUpDataReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + StorageAdminService_waitingForCatchUpData_pargs args; + args.get<0>().value = const_cast< ::nebula::storage::cpp2::CatchUpDataReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "waitingForCatchUpData"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void StorageAdminServiceAsyncClient::createCheckpointT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::CreateCPRequest& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + StorageAdminService_createCheckpoint_pargs args; + args.get<0>().value = const_cast< ::nebula::storage::cpp2::CreateCPRequest*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "createCheckpoint"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void StorageAdminServiceAsyncClient::dropCheckpointT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::DropCPRequest& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + StorageAdminService_dropCheckpoint_pargs args; + args.get<0>().value = const_cast< ::nebula::storage::cpp2::DropCPRequest*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "dropCheckpoint"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void StorageAdminServiceAsyncClient::blockingWritesT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::BlockingSignRequest& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + StorageAdminService_blockingWrites_pargs args; + args.get<0>().value = const_cast< ::nebula::storage::cpp2::BlockingSignRequest*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "blockingWrites"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void StorageAdminServiceAsyncClient::rebuildTagIndexT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::RebuildIndexRequest& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + StorageAdminService_rebuildTagIndex_pargs args; + args.get<0>().value = const_cast< ::nebula::storage::cpp2::RebuildIndexRequest*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "rebuildTagIndex"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void StorageAdminServiceAsyncClient::rebuildEdgeIndexT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::RebuildIndexRequest& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + StorageAdminService_rebuildEdgeIndex_pargs args; + args.get<0>().value = const_cast< ::nebula::storage::cpp2::RebuildIndexRequest*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "rebuildEdgeIndex"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void StorageAdminServiceAsyncClient::getLeaderPartsT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::GetLeaderReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + StorageAdminService_getLeaderParts_pargs args; + args.get<0>().value = const_cast< ::nebula::storage::cpp2::GetLeaderReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "getLeaderParts"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void StorageAdminServiceAsyncClient::checkPeersT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::CheckPeersReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + StorageAdminService_checkPeers_pargs args; + args.get<0>().value = const_cast< ::nebula::storage::cpp2::CheckPeersReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "checkPeers"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void StorageAdminServiceAsyncClient::addAdminTaskT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::AddAdminTaskRequest& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + StorageAdminService_addAdminTask_pargs args; + args.get<0>().value = const_cast< ::nebula::storage::cpp2::AddAdminTaskRequest*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "addAdminTask"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void StorageAdminServiceAsyncClient::stopAdminTaskT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::StopAdminTaskRequest& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + StorageAdminService_stopAdminTask_pargs args; + args.get<0>().value = const_cast< ::nebula::storage::cpp2::StopAdminTaskRequest*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "stopAdminTask"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + +template +void StorageAdminServiceAsyncClient::listClusterInfoT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::ListClusterInfoReq& p_req) { + + std::shared_ptr header(ctx, &ctx->header); + StorageAdminService_listClusterInfo_pargs args; + args.get<0>().value = const_cast< ::nebula::storage::cpp2::ListClusterInfoReq*>(&p_req); + auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); }; + auto writer = [&](Protocol_* p) { args.write(p); }; + static constexpr const folly::StringPiece methodName = "listClusterInfo"; + apache::thrift::clientSendT(prot, std::move(rpcOptions), std::move(callback), ctx->ctx, std::move(header), channel_.get(), apache::thrift::ManagedStringView(methodName, false), writer, sizer); + ctx->reqContext.setRequestHeader(nullptr); +} + + + +void StorageAdminServiceAsyncClient::transLeader(std::unique_ptr callback, const ::nebula::storage::cpp2::TransLeaderReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + transLeader(rpcOptions, std::move(callback), p_req); +} + +void StorageAdminServiceAsyncClient::transLeader(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::storage::cpp2::TransLeaderReq& p_req) { + auto ctx = transLeaderCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + transLeaderImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void StorageAdminServiceAsyncClient::transLeaderImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::TransLeaderReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + transLeaderT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + transLeaderT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> StorageAdminServiceAsyncClient::transLeaderCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "StorageAdminService.transLeader"); +} + +void StorageAdminServiceAsyncClient::sync_transLeader( ::nebula::storage::cpp2::AdminExecResp& _return, const ::nebula::storage::cpp2::TransLeaderReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_transLeader(rpcOptions, _return, p_req); +} + +void StorageAdminServiceAsyncClient::sync_transLeader(apache::thrift::RpcOptions& rpcOptions, ::nebula::storage::cpp2::AdminExecResp& _return, const ::nebula::storage::cpp2::TransLeaderReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = transLeaderCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + transLeaderImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_transLeader(_return, returnState); + }); +} + + +folly::Future< ::nebula::storage::cpp2::AdminExecResp> StorageAdminServiceAsyncClient::future_transLeader(const ::nebula::storage::cpp2::TransLeaderReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_transLeader(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::storage::cpp2::AdminExecResp> StorageAdminServiceAsyncClient::semifuture_transLeader(const ::nebula::storage::cpp2::TransLeaderReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_transLeader(rpcOptions, p_req); +} + +folly::Future< ::nebula::storage::cpp2::AdminExecResp> StorageAdminServiceAsyncClient::future_transLeader(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::TransLeaderReq& p_req) { + folly::Promise< ::nebula::storage::cpp2::AdminExecResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_transLeader, channel_); + transLeader(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::storage::cpp2::AdminExecResp> StorageAdminServiceAsyncClient::semifuture_transLeader(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::TransLeaderReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_transLeader, channel_); + auto callback = std::move(callbackAndFuture.first); + transLeader(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> StorageAdminServiceAsyncClient::header_future_transLeader(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::TransLeaderReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_transLeader, channel_); + transLeader(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> StorageAdminServiceAsyncClient::header_semifuture_transLeader(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::TransLeaderReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_transLeader, channel_); + auto callback = std::move(callbackAndFuture.first); + transLeader(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void StorageAdminServiceAsyncClient::transLeader(folly::Function callback, const ::nebula::storage::cpp2::TransLeaderReq& p_req) { + transLeader(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper StorageAdminServiceAsyncClient::recv_wrapped_transLeader( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = StorageAdminService_transLeader_presult; + constexpr auto const fname = "transLeader"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void StorageAdminServiceAsyncClient::recv_transLeader( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_transLeader(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void StorageAdminServiceAsyncClient::recv_instance_transLeader( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_transLeader(_return, state); +} + +folly::exception_wrapper StorageAdminServiceAsyncClient::recv_instance_wrapped_transLeader( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_transLeader(_return, state); +} + +void StorageAdminServiceAsyncClient::addPart(std::unique_ptr callback, const ::nebula::storage::cpp2::AddPartReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + addPart(rpcOptions, std::move(callback), p_req); +} + +void StorageAdminServiceAsyncClient::addPart(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::storage::cpp2::AddPartReq& p_req) { + auto ctx = addPartCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + addPartImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void StorageAdminServiceAsyncClient::addPartImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::AddPartReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + addPartT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + addPartT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> StorageAdminServiceAsyncClient::addPartCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "StorageAdminService.addPart"); +} + +void StorageAdminServiceAsyncClient::sync_addPart( ::nebula::storage::cpp2::AdminExecResp& _return, const ::nebula::storage::cpp2::AddPartReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_addPart(rpcOptions, _return, p_req); +} + +void StorageAdminServiceAsyncClient::sync_addPart(apache::thrift::RpcOptions& rpcOptions, ::nebula::storage::cpp2::AdminExecResp& _return, const ::nebula::storage::cpp2::AddPartReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = addPartCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + addPartImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_addPart(_return, returnState); + }); +} + + +folly::Future< ::nebula::storage::cpp2::AdminExecResp> StorageAdminServiceAsyncClient::future_addPart(const ::nebula::storage::cpp2::AddPartReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_addPart(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::storage::cpp2::AdminExecResp> StorageAdminServiceAsyncClient::semifuture_addPart(const ::nebula::storage::cpp2::AddPartReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_addPart(rpcOptions, p_req); +} + +folly::Future< ::nebula::storage::cpp2::AdminExecResp> StorageAdminServiceAsyncClient::future_addPart(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::AddPartReq& p_req) { + folly::Promise< ::nebula::storage::cpp2::AdminExecResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_addPart, channel_); + addPart(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::storage::cpp2::AdminExecResp> StorageAdminServiceAsyncClient::semifuture_addPart(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::AddPartReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_addPart, channel_); + auto callback = std::move(callbackAndFuture.first); + addPart(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> StorageAdminServiceAsyncClient::header_future_addPart(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::AddPartReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_addPart, channel_); + addPart(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> StorageAdminServiceAsyncClient::header_semifuture_addPart(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::AddPartReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_addPart, channel_); + auto callback = std::move(callbackAndFuture.first); + addPart(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void StorageAdminServiceAsyncClient::addPart(folly::Function callback, const ::nebula::storage::cpp2::AddPartReq& p_req) { + addPart(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper StorageAdminServiceAsyncClient::recv_wrapped_addPart( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = StorageAdminService_addPart_presult; + constexpr auto const fname = "addPart"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void StorageAdminServiceAsyncClient::recv_addPart( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_addPart(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void StorageAdminServiceAsyncClient::recv_instance_addPart( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_addPart(_return, state); +} + +folly::exception_wrapper StorageAdminServiceAsyncClient::recv_instance_wrapped_addPart( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_addPart(_return, state); +} + +void StorageAdminServiceAsyncClient::addLearner(std::unique_ptr callback, const ::nebula::storage::cpp2::AddLearnerReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + addLearner(rpcOptions, std::move(callback), p_req); +} + +void StorageAdminServiceAsyncClient::addLearner(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::storage::cpp2::AddLearnerReq& p_req) { + auto ctx = addLearnerCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + addLearnerImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void StorageAdminServiceAsyncClient::addLearnerImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::AddLearnerReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + addLearnerT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + addLearnerT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> StorageAdminServiceAsyncClient::addLearnerCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "StorageAdminService.addLearner"); +} + +void StorageAdminServiceAsyncClient::sync_addLearner( ::nebula::storage::cpp2::AdminExecResp& _return, const ::nebula::storage::cpp2::AddLearnerReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_addLearner(rpcOptions, _return, p_req); +} + +void StorageAdminServiceAsyncClient::sync_addLearner(apache::thrift::RpcOptions& rpcOptions, ::nebula::storage::cpp2::AdminExecResp& _return, const ::nebula::storage::cpp2::AddLearnerReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = addLearnerCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + addLearnerImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_addLearner(_return, returnState); + }); +} + + +folly::Future< ::nebula::storage::cpp2::AdminExecResp> StorageAdminServiceAsyncClient::future_addLearner(const ::nebula::storage::cpp2::AddLearnerReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_addLearner(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::storage::cpp2::AdminExecResp> StorageAdminServiceAsyncClient::semifuture_addLearner(const ::nebula::storage::cpp2::AddLearnerReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_addLearner(rpcOptions, p_req); +} + +folly::Future< ::nebula::storage::cpp2::AdminExecResp> StorageAdminServiceAsyncClient::future_addLearner(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::AddLearnerReq& p_req) { + folly::Promise< ::nebula::storage::cpp2::AdminExecResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_addLearner, channel_); + addLearner(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::storage::cpp2::AdminExecResp> StorageAdminServiceAsyncClient::semifuture_addLearner(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::AddLearnerReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_addLearner, channel_); + auto callback = std::move(callbackAndFuture.first); + addLearner(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> StorageAdminServiceAsyncClient::header_future_addLearner(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::AddLearnerReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_addLearner, channel_); + addLearner(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> StorageAdminServiceAsyncClient::header_semifuture_addLearner(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::AddLearnerReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_addLearner, channel_); + auto callback = std::move(callbackAndFuture.first); + addLearner(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void StorageAdminServiceAsyncClient::addLearner(folly::Function callback, const ::nebula::storage::cpp2::AddLearnerReq& p_req) { + addLearner(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper StorageAdminServiceAsyncClient::recv_wrapped_addLearner( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = StorageAdminService_addLearner_presult; + constexpr auto const fname = "addLearner"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void StorageAdminServiceAsyncClient::recv_addLearner( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_addLearner(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void StorageAdminServiceAsyncClient::recv_instance_addLearner( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_addLearner(_return, state); +} + +folly::exception_wrapper StorageAdminServiceAsyncClient::recv_instance_wrapped_addLearner( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_addLearner(_return, state); +} + +void StorageAdminServiceAsyncClient::removePart(std::unique_ptr callback, const ::nebula::storage::cpp2::RemovePartReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + removePart(rpcOptions, std::move(callback), p_req); +} + +void StorageAdminServiceAsyncClient::removePart(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::storage::cpp2::RemovePartReq& p_req) { + auto ctx = removePartCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + removePartImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void StorageAdminServiceAsyncClient::removePartImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::RemovePartReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + removePartT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + removePartT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> StorageAdminServiceAsyncClient::removePartCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "StorageAdminService.removePart"); +} + +void StorageAdminServiceAsyncClient::sync_removePart( ::nebula::storage::cpp2::AdminExecResp& _return, const ::nebula::storage::cpp2::RemovePartReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_removePart(rpcOptions, _return, p_req); +} + +void StorageAdminServiceAsyncClient::sync_removePart(apache::thrift::RpcOptions& rpcOptions, ::nebula::storage::cpp2::AdminExecResp& _return, const ::nebula::storage::cpp2::RemovePartReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = removePartCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + removePartImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_removePart(_return, returnState); + }); +} + + +folly::Future< ::nebula::storage::cpp2::AdminExecResp> StorageAdminServiceAsyncClient::future_removePart(const ::nebula::storage::cpp2::RemovePartReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_removePart(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::storage::cpp2::AdminExecResp> StorageAdminServiceAsyncClient::semifuture_removePart(const ::nebula::storage::cpp2::RemovePartReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_removePart(rpcOptions, p_req); +} + +folly::Future< ::nebula::storage::cpp2::AdminExecResp> StorageAdminServiceAsyncClient::future_removePart(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::RemovePartReq& p_req) { + folly::Promise< ::nebula::storage::cpp2::AdminExecResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_removePart, channel_); + removePart(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::storage::cpp2::AdminExecResp> StorageAdminServiceAsyncClient::semifuture_removePart(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::RemovePartReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_removePart, channel_); + auto callback = std::move(callbackAndFuture.first); + removePart(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> StorageAdminServiceAsyncClient::header_future_removePart(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::RemovePartReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_removePart, channel_); + removePart(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> StorageAdminServiceAsyncClient::header_semifuture_removePart(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::RemovePartReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_removePart, channel_); + auto callback = std::move(callbackAndFuture.first); + removePart(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void StorageAdminServiceAsyncClient::removePart(folly::Function callback, const ::nebula::storage::cpp2::RemovePartReq& p_req) { + removePart(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper StorageAdminServiceAsyncClient::recv_wrapped_removePart( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = StorageAdminService_removePart_presult; + constexpr auto const fname = "removePart"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void StorageAdminServiceAsyncClient::recv_removePart( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_removePart(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void StorageAdminServiceAsyncClient::recv_instance_removePart( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_removePart(_return, state); +} + +folly::exception_wrapper StorageAdminServiceAsyncClient::recv_instance_wrapped_removePart( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_removePart(_return, state); +} + +void StorageAdminServiceAsyncClient::memberChange(std::unique_ptr callback, const ::nebula::storage::cpp2::MemberChangeReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + memberChange(rpcOptions, std::move(callback), p_req); +} + +void StorageAdminServiceAsyncClient::memberChange(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::storage::cpp2::MemberChangeReq& p_req) { + auto ctx = memberChangeCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + memberChangeImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void StorageAdminServiceAsyncClient::memberChangeImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::MemberChangeReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + memberChangeT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + memberChangeT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> StorageAdminServiceAsyncClient::memberChangeCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "StorageAdminService.memberChange"); +} + +void StorageAdminServiceAsyncClient::sync_memberChange( ::nebula::storage::cpp2::AdminExecResp& _return, const ::nebula::storage::cpp2::MemberChangeReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_memberChange(rpcOptions, _return, p_req); +} + +void StorageAdminServiceAsyncClient::sync_memberChange(apache::thrift::RpcOptions& rpcOptions, ::nebula::storage::cpp2::AdminExecResp& _return, const ::nebula::storage::cpp2::MemberChangeReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = memberChangeCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + memberChangeImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_memberChange(_return, returnState); + }); +} + + +folly::Future< ::nebula::storage::cpp2::AdminExecResp> StorageAdminServiceAsyncClient::future_memberChange(const ::nebula::storage::cpp2::MemberChangeReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_memberChange(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::storage::cpp2::AdminExecResp> StorageAdminServiceAsyncClient::semifuture_memberChange(const ::nebula::storage::cpp2::MemberChangeReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_memberChange(rpcOptions, p_req); +} + +folly::Future< ::nebula::storage::cpp2::AdminExecResp> StorageAdminServiceAsyncClient::future_memberChange(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::MemberChangeReq& p_req) { + folly::Promise< ::nebula::storage::cpp2::AdminExecResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_memberChange, channel_); + memberChange(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::storage::cpp2::AdminExecResp> StorageAdminServiceAsyncClient::semifuture_memberChange(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::MemberChangeReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_memberChange, channel_); + auto callback = std::move(callbackAndFuture.first); + memberChange(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> StorageAdminServiceAsyncClient::header_future_memberChange(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::MemberChangeReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_memberChange, channel_); + memberChange(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> StorageAdminServiceAsyncClient::header_semifuture_memberChange(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::MemberChangeReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_memberChange, channel_); + auto callback = std::move(callbackAndFuture.first); + memberChange(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void StorageAdminServiceAsyncClient::memberChange(folly::Function callback, const ::nebula::storage::cpp2::MemberChangeReq& p_req) { + memberChange(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper StorageAdminServiceAsyncClient::recv_wrapped_memberChange( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = StorageAdminService_memberChange_presult; + constexpr auto const fname = "memberChange"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void StorageAdminServiceAsyncClient::recv_memberChange( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_memberChange(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void StorageAdminServiceAsyncClient::recv_instance_memberChange( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_memberChange(_return, state); +} + +folly::exception_wrapper StorageAdminServiceAsyncClient::recv_instance_wrapped_memberChange( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_memberChange(_return, state); +} + +void StorageAdminServiceAsyncClient::waitingForCatchUpData(std::unique_ptr callback, const ::nebula::storage::cpp2::CatchUpDataReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + waitingForCatchUpData(rpcOptions, std::move(callback), p_req); +} + +void StorageAdminServiceAsyncClient::waitingForCatchUpData(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::storage::cpp2::CatchUpDataReq& p_req) { + auto ctx = waitingForCatchUpDataCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + waitingForCatchUpDataImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void StorageAdminServiceAsyncClient::waitingForCatchUpDataImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::CatchUpDataReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + waitingForCatchUpDataT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + waitingForCatchUpDataT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> StorageAdminServiceAsyncClient::waitingForCatchUpDataCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "StorageAdminService.waitingForCatchUpData"); +} + +void StorageAdminServiceAsyncClient::sync_waitingForCatchUpData( ::nebula::storage::cpp2::AdminExecResp& _return, const ::nebula::storage::cpp2::CatchUpDataReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_waitingForCatchUpData(rpcOptions, _return, p_req); +} + +void StorageAdminServiceAsyncClient::sync_waitingForCatchUpData(apache::thrift::RpcOptions& rpcOptions, ::nebula::storage::cpp2::AdminExecResp& _return, const ::nebula::storage::cpp2::CatchUpDataReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = waitingForCatchUpDataCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + waitingForCatchUpDataImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_waitingForCatchUpData(_return, returnState); + }); +} + + +folly::Future< ::nebula::storage::cpp2::AdminExecResp> StorageAdminServiceAsyncClient::future_waitingForCatchUpData(const ::nebula::storage::cpp2::CatchUpDataReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_waitingForCatchUpData(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::storage::cpp2::AdminExecResp> StorageAdminServiceAsyncClient::semifuture_waitingForCatchUpData(const ::nebula::storage::cpp2::CatchUpDataReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_waitingForCatchUpData(rpcOptions, p_req); +} + +folly::Future< ::nebula::storage::cpp2::AdminExecResp> StorageAdminServiceAsyncClient::future_waitingForCatchUpData(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::CatchUpDataReq& p_req) { + folly::Promise< ::nebula::storage::cpp2::AdminExecResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_waitingForCatchUpData, channel_); + waitingForCatchUpData(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::storage::cpp2::AdminExecResp> StorageAdminServiceAsyncClient::semifuture_waitingForCatchUpData(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::CatchUpDataReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_waitingForCatchUpData, channel_); + auto callback = std::move(callbackAndFuture.first); + waitingForCatchUpData(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> StorageAdminServiceAsyncClient::header_future_waitingForCatchUpData(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::CatchUpDataReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_waitingForCatchUpData, channel_); + waitingForCatchUpData(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> StorageAdminServiceAsyncClient::header_semifuture_waitingForCatchUpData(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::CatchUpDataReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_waitingForCatchUpData, channel_); + auto callback = std::move(callbackAndFuture.first); + waitingForCatchUpData(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void StorageAdminServiceAsyncClient::waitingForCatchUpData(folly::Function callback, const ::nebula::storage::cpp2::CatchUpDataReq& p_req) { + waitingForCatchUpData(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper StorageAdminServiceAsyncClient::recv_wrapped_waitingForCatchUpData( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = StorageAdminService_waitingForCatchUpData_presult; + constexpr auto const fname = "waitingForCatchUpData"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void StorageAdminServiceAsyncClient::recv_waitingForCatchUpData( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_waitingForCatchUpData(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void StorageAdminServiceAsyncClient::recv_instance_waitingForCatchUpData( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_waitingForCatchUpData(_return, state); +} + +folly::exception_wrapper StorageAdminServiceAsyncClient::recv_instance_wrapped_waitingForCatchUpData( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_waitingForCatchUpData(_return, state); +} + +void StorageAdminServiceAsyncClient::createCheckpoint(std::unique_ptr callback, const ::nebula::storage::cpp2::CreateCPRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + createCheckpoint(rpcOptions, std::move(callback), p_req); +} + +void StorageAdminServiceAsyncClient::createCheckpoint(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::storage::cpp2::CreateCPRequest& p_req) { + auto ctx = createCheckpointCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + createCheckpointImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void StorageAdminServiceAsyncClient::createCheckpointImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::CreateCPRequest& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + createCheckpointT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + createCheckpointT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> StorageAdminServiceAsyncClient::createCheckpointCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "StorageAdminService.createCheckpoint"); +} + +void StorageAdminServiceAsyncClient::sync_createCheckpoint( ::nebula::storage::cpp2::CreateCPResp& _return, const ::nebula::storage::cpp2::CreateCPRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_createCheckpoint(rpcOptions, _return, p_req); +} + +void StorageAdminServiceAsyncClient::sync_createCheckpoint(apache::thrift::RpcOptions& rpcOptions, ::nebula::storage::cpp2::CreateCPResp& _return, const ::nebula::storage::cpp2::CreateCPRequest& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = createCheckpointCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + createCheckpointImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_createCheckpoint(_return, returnState); + }); +} + + +folly::Future< ::nebula::storage::cpp2::CreateCPResp> StorageAdminServiceAsyncClient::future_createCheckpoint(const ::nebula::storage::cpp2::CreateCPRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_createCheckpoint(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::storage::cpp2::CreateCPResp> StorageAdminServiceAsyncClient::semifuture_createCheckpoint(const ::nebula::storage::cpp2::CreateCPRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_createCheckpoint(rpcOptions, p_req); +} + +folly::Future< ::nebula::storage::cpp2::CreateCPResp> StorageAdminServiceAsyncClient::future_createCheckpoint(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::CreateCPRequest& p_req) { + folly::Promise< ::nebula::storage::cpp2::CreateCPResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_createCheckpoint, channel_); + createCheckpoint(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::storage::cpp2::CreateCPResp> StorageAdminServiceAsyncClient::semifuture_createCheckpoint(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::CreateCPRequest& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_createCheckpoint, channel_); + auto callback = std::move(callbackAndFuture.first); + createCheckpoint(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> StorageAdminServiceAsyncClient::header_future_createCheckpoint(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::CreateCPRequest& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_createCheckpoint, channel_); + createCheckpoint(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> StorageAdminServiceAsyncClient::header_semifuture_createCheckpoint(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::CreateCPRequest& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_createCheckpoint, channel_); + auto callback = std::move(callbackAndFuture.first); + createCheckpoint(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void StorageAdminServiceAsyncClient::createCheckpoint(folly::Function callback, const ::nebula::storage::cpp2::CreateCPRequest& p_req) { + createCheckpoint(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper StorageAdminServiceAsyncClient::recv_wrapped_createCheckpoint( ::nebula::storage::cpp2::CreateCPResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = StorageAdminService_createCheckpoint_presult; + constexpr auto const fname = "createCheckpoint"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void StorageAdminServiceAsyncClient::recv_createCheckpoint( ::nebula::storage::cpp2::CreateCPResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_createCheckpoint(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void StorageAdminServiceAsyncClient::recv_instance_createCheckpoint( ::nebula::storage::cpp2::CreateCPResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_createCheckpoint(_return, state); +} + +folly::exception_wrapper StorageAdminServiceAsyncClient::recv_instance_wrapped_createCheckpoint( ::nebula::storage::cpp2::CreateCPResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_createCheckpoint(_return, state); +} + +void StorageAdminServiceAsyncClient::dropCheckpoint(std::unique_ptr callback, const ::nebula::storage::cpp2::DropCPRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + dropCheckpoint(rpcOptions, std::move(callback), p_req); +} + +void StorageAdminServiceAsyncClient::dropCheckpoint(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::storage::cpp2::DropCPRequest& p_req) { + auto ctx = dropCheckpointCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + dropCheckpointImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void StorageAdminServiceAsyncClient::dropCheckpointImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::DropCPRequest& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + dropCheckpointT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + dropCheckpointT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> StorageAdminServiceAsyncClient::dropCheckpointCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "StorageAdminService.dropCheckpoint"); +} + +void StorageAdminServiceAsyncClient::sync_dropCheckpoint( ::nebula::storage::cpp2::AdminExecResp& _return, const ::nebula::storage::cpp2::DropCPRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_dropCheckpoint(rpcOptions, _return, p_req); +} + +void StorageAdminServiceAsyncClient::sync_dropCheckpoint(apache::thrift::RpcOptions& rpcOptions, ::nebula::storage::cpp2::AdminExecResp& _return, const ::nebula::storage::cpp2::DropCPRequest& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = dropCheckpointCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + dropCheckpointImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_dropCheckpoint(_return, returnState); + }); +} + + +folly::Future< ::nebula::storage::cpp2::AdminExecResp> StorageAdminServiceAsyncClient::future_dropCheckpoint(const ::nebula::storage::cpp2::DropCPRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_dropCheckpoint(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::storage::cpp2::AdminExecResp> StorageAdminServiceAsyncClient::semifuture_dropCheckpoint(const ::nebula::storage::cpp2::DropCPRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_dropCheckpoint(rpcOptions, p_req); +} + +folly::Future< ::nebula::storage::cpp2::AdminExecResp> StorageAdminServiceAsyncClient::future_dropCheckpoint(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::DropCPRequest& p_req) { + folly::Promise< ::nebula::storage::cpp2::AdminExecResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_dropCheckpoint, channel_); + dropCheckpoint(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::storage::cpp2::AdminExecResp> StorageAdminServiceAsyncClient::semifuture_dropCheckpoint(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::DropCPRequest& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_dropCheckpoint, channel_); + auto callback = std::move(callbackAndFuture.first); + dropCheckpoint(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> StorageAdminServiceAsyncClient::header_future_dropCheckpoint(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::DropCPRequest& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_dropCheckpoint, channel_); + dropCheckpoint(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> StorageAdminServiceAsyncClient::header_semifuture_dropCheckpoint(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::DropCPRequest& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_dropCheckpoint, channel_); + auto callback = std::move(callbackAndFuture.first); + dropCheckpoint(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void StorageAdminServiceAsyncClient::dropCheckpoint(folly::Function callback, const ::nebula::storage::cpp2::DropCPRequest& p_req) { + dropCheckpoint(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper StorageAdminServiceAsyncClient::recv_wrapped_dropCheckpoint( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = StorageAdminService_dropCheckpoint_presult; + constexpr auto const fname = "dropCheckpoint"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void StorageAdminServiceAsyncClient::recv_dropCheckpoint( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_dropCheckpoint(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void StorageAdminServiceAsyncClient::recv_instance_dropCheckpoint( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_dropCheckpoint(_return, state); +} + +folly::exception_wrapper StorageAdminServiceAsyncClient::recv_instance_wrapped_dropCheckpoint( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_dropCheckpoint(_return, state); +} + +void StorageAdminServiceAsyncClient::blockingWrites(std::unique_ptr callback, const ::nebula::storage::cpp2::BlockingSignRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + blockingWrites(rpcOptions, std::move(callback), p_req); +} + +void StorageAdminServiceAsyncClient::blockingWrites(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::storage::cpp2::BlockingSignRequest& p_req) { + auto ctx = blockingWritesCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + blockingWritesImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void StorageAdminServiceAsyncClient::blockingWritesImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::BlockingSignRequest& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + blockingWritesT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + blockingWritesT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> StorageAdminServiceAsyncClient::blockingWritesCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "StorageAdminService.blockingWrites"); +} + +void StorageAdminServiceAsyncClient::sync_blockingWrites( ::nebula::storage::cpp2::AdminExecResp& _return, const ::nebula::storage::cpp2::BlockingSignRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_blockingWrites(rpcOptions, _return, p_req); +} + +void StorageAdminServiceAsyncClient::sync_blockingWrites(apache::thrift::RpcOptions& rpcOptions, ::nebula::storage::cpp2::AdminExecResp& _return, const ::nebula::storage::cpp2::BlockingSignRequest& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = blockingWritesCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + blockingWritesImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_blockingWrites(_return, returnState); + }); +} + + +folly::Future< ::nebula::storage::cpp2::AdminExecResp> StorageAdminServiceAsyncClient::future_blockingWrites(const ::nebula::storage::cpp2::BlockingSignRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_blockingWrites(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::storage::cpp2::AdminExecResp> StorageAdminServiceAsyncClient::semifuture_blockingWrites(const ::nebula::storage::cpp2::BlockingSignRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_blockingWrites(rpcOptions, p_req); +} + +folly::Future< ::nebula::storage::cpp2::AdminExecResp> StorageAdminServiceAsyncClient::future_blockingWrites(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::BlockingSignRequest& p_req) { + folly::Promise< ::nebula::storage::cpp2::AdminExecResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_blockingWrites, channel_); + blockingWrites(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::storage::cpp2::AdminExecResp> StorageAdminServiceAsyncClient::semifuture_blockingWrites(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::BlockingSignRequest& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_blockingWrites, channel_); + auto callback = std::move(callbackAndFuture.first); + blockingWrites(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> StorageAdminServiceAsyncClient::header_future_blockingWrites(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::BlockingSignRequest& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_blockingWrites, channel_); + blockingWrites(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> StorageAdminServiceAsyncClient::header_semifuture_blockingWrites(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::BlockingSignRequest& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_blockingWrites, channel_); + auto callback = std::move(callbackAndFuture.first); + blockingWrites(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void StorageAdminServiceAsyncClient::blockingWrites(folly::Function callback, const ::nebula::storage::cpp2::BlockingSignRequest& p_req) { + blockingWrites(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper StorageAdminServiceAsyncClient::recv_wrapped_blockingWrites( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = StorageAdminService_blockingWrites_presult; + constexpr auto const fname = "blockingWrites"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void StorageAdminServiceAsyncClient::recv_blockingWrites( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_blockingWrites(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void StorageAdminServiceAsyncClient::recv_instance_blockingWrites( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_blockingWrites(_return, state); +} + +folly::exception_wrapper StorageAdminServiceAsyncClient::recv_instance_wrapped_blockingWrites( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_blockingWrites(_return, state); +} + +void StorageAdminServiceAsyncClient::rebuildTagIndex(std::unique_ptr callback, const ::nebula::storage::cpp2::RebuildIndexRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + rebuildTagIndex(rpcOptions, std::move(callback), p_req); +} + +void StorageAdminServiceAsyncClient::rebuildTagIndex(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::storage::cpp2::RebuildIndexRequest& p_req) { + auto ctx = rebuildTagIndexCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + rebuildTagIndexImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void StorageAdminServiceAsyncClient::rebuildTagIndexImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::RebuildIndexRequest& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + rebuildTagIndexT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + rebuildTagIndexT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> StorageAdminServiceAsyncClient::rebuildTagIndexCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "StorageAdminService.rebuildTagIndex"); +} + +void StorageAdminServiceAsyncClient::sync_rebuildTagIndex( ::nebula::storage::cpp2::AdminExecResp& _return, const ::nebula::storage::cpp2::RebuildIndexRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_rebuildTagIndex(rpcOptions, _return, p_req); +} + +void StorageAdminServiceAsyncClient::sync_rebuildTagIndex(apache::thrift::RpcOptions& rpcOptions, ::nebula::storage::cpp2::AdminExecResp& _return, const ::nebula::storage::cpp2::RebuildIndexRequest& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = rebuildTagIndexCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + rebuildTagIndexImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_rebuildTagIndex(_return, returnState); + }); +} + + +folly::Future< ::nebula::storage::cpp2::AdminExecResp> StorageAdminServiceAsyncClient::future_rebuildTagIndex(const ::nebula::storage::cpp2::RebuildIndexRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_rebuildTagIndex(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::storage::cpp2::AdminExecResp> StorageAdminServiceAsyncClient::semifuture_rebuildTagIndex(const ::nebula::storage::cpp2::RebuildIndexRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_rebuildTagIndex(rpcOptions, p_req); +} + +folly::Future< ::nebula::storage::cpp2::AdminExecResp> StorageAdminServiceAsyncClient::future_rebuildTagIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::RebuildIndexRequest& p_req) { + folly::Promise< ::nebula::storage::cpp2::AdminExecResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_rebuildTagIndex, channel_); + rebuildTagIndex(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::storage::cpp2::AdminExecResp> StorageAdminServiceAsyncClient::semifuture_rebuildTagIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::RebuildIndexRequest& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_rebuildTagIndex, channel_); + auto callback = std::move(callbackAndFuture.first); + rebuildTagIndex(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> StorageAdminServiceAsyncClient::header_future_rebuildTagIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::RebuildIndexRequest& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_rebuildTagIndex, channel_); + rebuildTagIndex(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> StorageAdminServiceAsyncClient::header_semifuture_rebuildTagIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::RebuildIndexRequest& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_rebuildTagIndex, channel_); + auto callback = std::move(callbackAndFuture.first); + rebuildTagIndex(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void StorageAdminServiceAsyncClient::rebuildTagIndex(folly::Function callback, const ::nebula::storage::cpp2::RebuildIndexRequest& p_req) { + rebuildTagIndex(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper StorageAdminServiceAsyncClient::recv_wrapped_rebuildTagIndex( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = StorageAdminService_rebuildTagIndex_presult; + constexpr auto const fname = "rebuildTagIndex"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void StorageAdminServiceAsyncClient::recv_rebuildTagIndex( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_rebuildTagIndex(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void StorageAdminServiceAsyncClient::recv_instance_rebuildTagIndex( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_rebuildTagIndex(_return, state); +} + +folly::exception_wrapper StorageAdminServiceAsyncClient::recv_instance_wrapped_rebuildTagIndex( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_rebuildTagIndex(_return, state); +} + +void StorageAdminServiceAsyncClient::rebuildEdgeIndex(std::unique_ptr callback, const ::nebula::storage::cpp2::RebuildIndexRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + rebuildEdgeIndex(rpcOptions, std::move(callback), p_req); +} + +void StorageAdminServiceAsyncClient::rebuildEdgeIndex(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::storage::cpp2::RebuildIndexRequest& p_req) { + auto ctx = rebuildEdgeIndexCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + rebuildEdgeIndexImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void StorageAdminServiceAsyncClient::rebuildEdgeIndexImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::RebuildIndexRequest& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + rebuildEdgeIndexT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + rebuildEdgeIndexT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> StorageAdminServiceAsyncClient::rebuildEdgeIndexCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "StorageAdminService.rebuildEdgeIndex"); +} + +void StorageAdminServiceAsyncClient::sync_rebuildEdgeIndex( ::nebula::storage::cpp2::AdminExecResp& _return, const ::nebula::storage::cpp2::RebuildIndexRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_rebuildEdgeIndex(rpcOptions, _return, p_req); +} + +void StorageAdminServiceAsyncClient::sync_rebuildEdgeIndex(apache::thrift::RpcOptions& rpcOptions, ::nebula::storage::cpp2::AdminExecResp& _return, const ::nebula::storage::cpp2::RebuildIndexRequest& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = rebuildEdgeIndexCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + rebuildEdgeIndexImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_rebuildEdgeIndex(_return, returnState); + }); +} + + +folly::Future< ::nebula::storage::cpp2::AdminExecResp> StorageAdminServiceAsyncClient::future_rebuildEdgeIndex(const ::nebula::storage::cpp2::RebuildIndexRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_rebuildEdgeIndex(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::storage::cpp2::AdminExecResp> StorageAdminServiceAsyncClient::semifuture_rebuildEdgeIndex(const ::nebula::storage::cpp2::RebuildIndexRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_rebuildEdgeIndex(rpcOptions, p_req); +} + +folly::Future< ::nebula::storage::cpp2::AdminExecResp> StorageAdminServiceAsyncClient::future_rebuildEdgeIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::RebuildIndexRequest& p_req) { + folly::Promise< ::nebula::storage::cpp2::AdminExecResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_rebuildEdgeIndex, channel_); + rebuildEdgeIndex(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::storage::cpp2::AdminExecResp> StorageAdminServiceAsyncClient::semifuture_rebuildEdgeIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::RebuildIndexRequest& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_rebuildEdgeIndex, channel_); + auto callback = std::move(callbackAndFuture.first); + rebuildEdgeIndex(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> StorageAdminServiceAsyncClient::header_future_rebuildEdgeIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::RebuildIndexRequest& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_rebuildEdgeIndex, channel_); + rebuildEdgeIndex(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> StorageAdminServiceAsyncClient::header_semifuture_rebuildEdgeIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::RebuildIndexRequest& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_rebuildEdgeIndex, channel_); + auto callback = std::move(callbackAndFuture.first); + rebuildEdgeIndex(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void StorageAdminServiceAsyncClient::rebuildEdgeIndex(folly::Function callback, const ::nebula::storage::cpp2::RebuildIndexRequest& p_req) { + rebuildEdgeIndex(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper StorageAdminServiceAsyncClient::recv_wrapped_rebuildEdgeIndex( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = StorageAdminService_rebuildEdgeIndex_presult; + constexpr auto const fname = "rebuildEdgeIndex"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void StorageAdminServiceAsyncClient::recv_rebuildEdgeIndex( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_rebuildEdgeIndex(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void StorageAdminServiceAsyncClient::recv_instance_rebuildEdgeIndex( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_rebuildEdgeIndex(_return, state); +} + +folly::exception_wrapper StorageAdminServiceAsyncClient::recv_instance_wrapped_rebuildEdgeIndex( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_rebuildEdgeIndex(_return, state); +} + +void StorageAdminServiceAsyncClient::getLeaderParts(std::unique_ptr callback, const ::nebula::storage::cpp2::GetLeaderReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + getLeaderParts(rpcOptions, std::move(callback), p_req); +} + +void StorageAdminServiceAsyncClient::getLeaderParts(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::storage::cpp2::GetLeaderReq& p_req) { + auto ctx = getLeaderPartsCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + getLeaderPartsImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void StorageAdminServiceAsyncClient::getLeaderPartsImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::GetLeaderReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + getLeaderPartsT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + getLeaderPartsT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> StorageAdminServiceAsyncClient::getLeaderPartsCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "StorageAdminService.getLeaderParts"); +} + +void StorageAdminServiceAsyncClient::sync_getLeaderParts( ::nebula::storage::cpp2::GetLeaderPartsResp& _return, const ::nebula::storage::cpp2::GetLeaderReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_getLeaderParts(rpcOptions, _return, p_req); +} + +void StorageAdminServiceAsyncClient::sync_getLeaderParts(apache::thrift::RpcOptions& rpcOptions, ::nebula::storage::cpp2::GetLeaderPartsResp& _return, const ::nebula::storage::cpp2::GetLeaderReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = getLeaderPartsCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + getLeaderPartsImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_getLeaderParts(_return, returnState); + }); +} + + +folly::Future< ::nebula::storage::cpp2::GetLeaderPartsResp> StorageAdminServiceAsyncClient::future_getLeaderParts(const ::nebula::storage::cpp2::GetLeaderReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_getLeaderParts(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::storage::cpp2::GetLeaderPartsResp> StorageAdminServiceAsyncClient::semifuture_getLeaderParts(const ::nebula::storage::cpp2::GetLeaderReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_getLeaderParts(rpcOptions, p_req); +} + +folly::Future< ::nebula::storage::cpp2::GetLeaderPartsResp> StorageAdminServiceAsyncClient::future_getLeaderParts(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::GetLeaderReq& p_req) { + folly::Promise< ::nebula::storage::cpp2::GetLeaderPartsResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_getLeaderParts, channel_); + getLeaderParts(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::storage::cpp2::GetLeaderPartsResp> StorageAdminServiceAsyncClient::semifuture_getLeaderParts(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::GetLeaderReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_getLeaderParts, channel_); + auto callback = std::move(callbackAndFuture.first); + getLeaderParts(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> StorageAdminServiceAsyncClient::header_future_getLeaderParts(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::GetLeaderReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_getLeaderParts, channel_); + getLeaderParts(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> StorageAdminServiceAsyncClient::header_semifuture_getLeaderParts(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::GetLeaderReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_getLeaderParts, channel_); + auto callback = std::move(callbackAndFuture.first); + getLeaderParts(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void StorageAdminServiceAsyncClient::getLeaderParts(folly::Function callback, const ::nebula::storage::cpp2::GetLeaderReq& p_req) { + getLeaderParts(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper StorageAdminServiceAsyncClient::recv_wrapped_getLeaderParts( ::nebula::storage::cpp2::GetLeaderPartsResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = StorageAdminService_getLeaderParts_presult; + constexpr auto const fname = "getLeaderParts"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void StorageAdminServiceAsyncClient::recv_getLeaderParts( ::nebula::storage::cpp2::GetLeaderPartsResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_getLeaderParts(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void StorageAdminServiceAsyncClient::recv_instance_getLeaderParts( ::nebula::storage::cpp2::GetLeaderPartsResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_getLeaderParts(_return, state); +} + +folly::exception_wrapper StorageAdminServiceAsyncClient::recv_instance_wrapped_getLeaderParts( ::nebula::storage::cpp2::GetLeaderPartsResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_getLeaderParts(_return, state); +} + +void StorageAdminServiceAsyncClient::checkPeers(std::unique_ptr callback, const ::nebula::storage::cpp2::CheckPeersReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + checkPeers(rpcOptions, std::move(callback), p_req); +} + +void StorageAdminServiceAsyncClient::checkPeers(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::storage::cpp2::CheckPeersReq& p_req) { + auto ctx = checkPeersCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + checkPeersImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void StorageAdminServiceAsyncClient::checkPeersImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::CheckPeersReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + checkPeersT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + checkPeersT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> StorageAdminServiceAsyncClient::checkPeersCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "StorageAdminService.checkPeers"); +} + +void StorageAdminServiceAsyncClient::sync_checkPeers( ::nebula::storage::cpp2::AdminExecResp& _return, const ::nebula::storage::cpp2::CheckPeersReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_checkPeers(rpcOptions, _return, p_req); +} + +void StorageAdminServiceAsyncClient::sync_checkPeers(apache::thrift::RpcOptions& rpcOptions, ::nebula::storage::cpp2::AdminExecResp& _return, const ::nebula::storage::cpp2::CheckPeersReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = checkPeersCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + checkPeersImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_checkPeers(_return, returnState); + }); +} + + +folly::Future< ::nebula::storage::cpp2::AdminExecResp> StorageAdminServiceAsyncClient::future_checkPeers(const ::nebula::storage::cpp2::CheckPeersReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_checkPeers(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::storage::cpp2::AdminExecResp> StorageAdminServiceAsyncClient::semifuture_checkPeers(const ::nebula::storage::cpp2::CheckPeersReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_checkPeers(rpcOptions, p_req); +} + +folly::Future< ::nebula::storage::cpp2::AdminExecResp> StorageAdminServiceAsyncClient::future_checkPeers(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::CheckPeersReq& p_req) { + folly::Promise< ::nebula::storage::cpp2::AdminExecResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_checkPeers, channel_); + checkPeers(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::storage::cpp2::AdminExecResp> StorageAdminServiceAsyncClient::semifuture_checkPeers(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::CheckPeersReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_checkPeers, channel_); + auto callback = std::move(callbackAndFuture.first); + checkPeers(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> StorageAdminServiceAsyncClient::header_future_checkPeers(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::CheckPeersReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_checkPeers, channel_); + checkPeers(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> StorageAdminServiceAsyncClient::header_semifuture_checkPeers(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::CheckPeersReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_checkPeers, channel_); + auto callback = std::move(callbackAndFuture.first); + checkPeers(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void StorageAdminServiceAsyncClient::checkPeers(folly::Function callback, const ::nebula::storage::cpp2::CheckPeersReq& p_req) { + checkPeers(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper StorageAdminServiceAsyncClient::recv_wrapped_checkPeers( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = StorageAdminService_checkPeers_presult; + constexpr auto const fname = "checkPeers"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void StorageAdminServiceAsyncClient::recv_checkPeers( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_checkPeers(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void StorageAdminServiceAsyncClient::recv_instance_checkPeers( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_checkPeers(_return, state); +} + +folly::exception_wrapper StorageAdminServiceAsyncClient::recv_instance_wrapped_checkPeers( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_checkPeers(_return, state); +} + +void StorageAdminServiceAsyncClient::addAdminTask(std::unique_ptr callback, const ::nebula::storage::cpp2::AddAdminTaskRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + addAdminTask(rpcOptions, std::move(callback), p_req); +} + +void StorageAdminServiceAsyncClient::addAdminTask(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::storage::cpp2::AddAdminTaskRequest& p_req) { + auto ctx = addAdminTaskCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + addAdminTaskImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void StorageAdminServiceAsyncClient::addAdminTaskImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::AddAdminTaskRequest& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + addAdminTaskT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + addAdminTaskT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> StorageAdminServiceAsyncClient::addAdminTaskCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "StorageAdminService.addAdminTask"); +} + +void StorageAdminServiceAsyncClient::sync_addAdminTask( ::nebula::storage::cpp2::AdminExecResp& _return, const ::nebula::storage::cpp2::AddAdminTaskRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_addAdminTask(rpcOptions, _return, p_req); +} + +void StorageAdminServiceAsyncClient::sync_addAdminTask(apache::thrift::RpcOptions& rpcOptions, ::nebula::storage::cpp2::AdminExecResp& _return, const ::nebula::storage::cpp2::AddAdminTaskRequest& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = addAdminTaskCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + addAdminTaskImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_addAdminTask(_return, returnState); + }); +} + + +folly::Future< ::nebula::storage::cpp2::AdminExecResp> StorageAdminServiceAsyncClient::future_addAdminTask(const ::nebula::storage::cpp2::AddAdminTaskRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_addAdminTask(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::storage::cpp2::AdminExecResp> StorageAdminServiceAsyncClient::semifuture_addAdminTask(const ::nebula::storage::cpp2::AddAdminTaskRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_addAdminTask(rpcOptions, p_req); +} + +folly::Future< ::nebula::storage::cpp2::AdminExecResp> StorageAdminServiceAsyncClient::future_addAdminTask(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::AddAdminTaskRequest& p_req) { + folly::Promise< ::nebula::storage::cpp2::AdminExecResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_addAdminTask, channel_); + addAdminTask(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::storage::cpp2::AdminExecResp> StorageAdminServiceAsyncClient::semifuture_addAdminTask(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::AddAdminTaskRequest& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_addAdminTask, channel_); + auto callback = std::move(callbackAndFuture.first); + addAdminTask(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> StorageAdminServiceAsyncClient::header_future_addAdminTask(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::AddAdminTaskRequest& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_addAdminTask, channel_); + addAdminTask(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> StorageAdminServiceAsyncClient::header_semifuture_addAdminTask(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::AddAdminTaskRequest& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_addAdminTask, channel_); + auto callback = std::move(callbackAndFuture.first); + addAdminTask(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void StorageAdminServiceAsyncClient::addAdminTask(folly::Function callback, const ::nebula::storage::cpp2::AddAdminTaskRequest& p_req) { + addAdminTask(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper StorageAdminServiceAsyncClient::recv_wrapped_addAdminTask( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = StorageAdminService_addAdminTask_presult; + constexpr auto const fname = "addAdminTask"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void StorageAdminServiceAsyncClient::recv_addAdminTask( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_addAdminTask(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void StorageAdminServiceAsyncClient::recv_instance_addAdminTask( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_addAdminTask(_return, state); +} + +folly::exception_wrapper StorageAdminServiceAsyncClient::recv_instance_wrapped_addAdminTask( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_addAdminTask(_return, state); +} + +void StorageAdminServiceAsyncClient::stopAdminTask(std::unique_ptr callback, const ::nebula::storage::cpp2::StopAdminTaskRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + stopAdminTask(rpcOptions, std::move(callback), p_req); +} + +void StorageAdminServiceAsyncClient::stopAdminTask(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::storage::cpp2::StopAdminTaskRequest& p_req) { + auto ctx = stopAdminTaskCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + stopAdminTaskImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void StorageAdminServiceAsyncClient::stopAdminTaskImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::StopAdminTaskRequest& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + stopAdminTaskT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + stopAdminTaskT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> StorageAdminServiceAsyncClient::stopAdminTaskCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "StorageAdminService.stopAdminTask"); +} + +void StorageAdminServiceAsyncClient::sync_stopAdminTask( ::nebula::storage::cpp2::AdminExecResp& _return, const ::nebula::storage::cpp2::StopAdminTaskRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_stopAdminTask(rpcOptions, _return, p_req); +} + +void StorageAdminServiceAsyncClient::sync_stopAdminTask(apache::thrift::RpcOptions& rpcOptions, ::nebula::storage::cpp2::AdminExecResp& _return, const ::nebula::storage::cpp2::StopAdminTaskRequest& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = stopAdminTaskCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + stopAdminTaskImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_stopAdminTask(_return, returnState); + }); +} + + +folly::Future< ::nebula::storage::cpp2::AdminExecResp> StorageAdminServiceAsyncClient::future_stopAdminTask(const ::nebula::storage::cpp2::StopAdminTaskRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_stopAdminTask(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::storage::cpp2::AdminExecResp> StorageAdminServiceAsyncClient::semifuture_stopAdminTask(const ::nebula::storage::cpp2::StopAdminTaskRequest& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_stopAdminTask(rpcOptions, p_req); +} + +folly::Future< ::nebula::storage::cpp2::AdminExecResp> StorageAdminServiceAsyncClient::future_stopAdminTask(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::StopAdminTaskRequest& p_req) { + folly::Promise< ::nebula::storage::cpp2::AdminExecResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_stopAdminTask, channel_); + stopAdminTask(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::storage::cpp2::AdminExecResp> StorageAdminServiceAsyncClient::semifuture_stopAdminTask(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::StopAdminTaskRequest& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_stopAdminTask, channel_); + auto callback = std::move(callbackAndFuture.first); + stopAdminTask(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> StorageAdminServiceAsyncClient::header_future_stopAdminTask(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::StopAdminTaskRequest& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_stopAdminTask, channel_); + stopAdminTask(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> StorageAdminServiceAsyncClient::header_semifuture_stopAdminTask(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::StopAdminTaskRequest& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_stopAdminTask, channel_); + auto callback = std::move(callbackAndFuture.first); + stopAdminTask(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void StorageAdminServiceAsyncClient::stopAdminTask(folly::Function callback, const ::nebula::storage::cpp2::StopAdminTaskRequest& p_req) { + stopAdminTask(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper StorageAdminServiceAsyncClient::recv_wrapped_stopAdminTask( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = StorageAdminService_stopAdminTask_presult; + constexpr auto const fname = "stopAdminTask"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void StorageAdminServiceAsyncClient::recv_stopAdminTask( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_stopAdminTask(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void StorageAdminServiceAsyncClient::recv_instance_stopAdminTask( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_stopAdminTask(_return, state); +} + +folly::exception_wrapper StorageAdminServiceAsyncClient::recv_instance_wrapped_stopAdminTask( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_stopAdminTask(_return, state); +} + +void StorageAdminServiceAsyncClient::listClusterInfo(std::unique_ptr callback, const ::nebula::storage::cpp2::ListClusterInfoReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + listClusterInfo(rpcOptions, std::move(callback), p_req); +} + +void StorageAdminServiceAsyncClient::listClusterInfo(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::storage::cpp2::ListClusterInfoReq& p_req) { + auto ctx = listClusterInfoCtx(&rpcOptions); + apache::thrift::RequestCallback::Context callbackContext; + callbackContext.protocolId = + apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + callbackContext.ctx = std::shared_ptr(ctx, &ctx->ctx); + auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext)); + listClusterInfoImpl(rpcOptions, std::move(ctx), std::move(wrappedCallback), p_req); +} + +void StorageAdminServiceAsyncClient::listClusterInfoImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::ListClusterInfoReq& p_req) { + switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolWriter writer; + listClusterInfoT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolWriter writer; + listClusterInfoT(&writer, rpcOptions, std::move(ctx), std::move(callback), p_req); + break; + } + default: + { + apache::thrift::detail::ac::throw_app_exn("Could not find Protocol"); + } + } +} + +std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> StorageAdminServiceAsyncClient::listClusterInfoCtx(apache::thrift::RpcOptions* rpcOptions) { + return std::make_shared( + channel_->getProtocolId(), + rpcOptions ? rpcOptions->releaseWriteHeaders() : std::map{}, + handlers_, + getServiceName(), + "StorageAdminService.listClusterInfo"); +} + +void StorageAdminServiceAsyncClient::sync_listClusterInfo( ::nebula::storage::cpp2::ListClusterInfoResp& _return, const ::nebula::storage::cpp2::ListClusterInfoReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + sync_listClusterInfo(rpcOptions, _return, p_req); +} + +void StorageAdminServiceAsyncClient::sync_listClusterInfo(apache::thrift::RpcOptions& rpcOptions, ::nebula::storage::cpp2::ListClusterInfoResp& _return, const ::nebula::storage::cpp2::ListClusterInfoReq& p_req) { + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase(); + auto ctx = listClusterInfoCtx(&rpcOptions); + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback); + listClusterInfoImpl(rpcOptions, ctx, std::move(wrappedCallback), p_req); + callback.waitUntilDone(evb); + + if (returnState.isException()) { + returnState.exception().throw_exception(); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions.setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + return folly::fibers::runInMainContext([&] { + recv_listClusterInfo(_return, returnState); + }); +} + + +folly::Future< ::nebula::storage::cpp2::ListClusterInfoResp> StorageAdminServiceAsyncClient::future_listClusterInfo(const ::nebula::storage::cpp2::ListClusterInfoReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return future_listClusterInfo(rpcOptions, p_req); +} + +folly::SemiFuture< ::nebula::storage::cpp2::ListClusterInfoResp> StorageAdminServiceAsyncClient::semifuture_listClusterInfo(const ::nebula::storage::cpp2::ListClusterInfoReq& p_req) { + ::apache::thrift::RpcOptions rpcOptions; + return semifuture_listClusterInfo(rpcOptions, p_req); +} + +folly::Future< ::nebula::storage::cpp2::ListClusterInfoResp> StorageAdminServiceAsyncClient::future_listClusterInfo(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::ListClusterInfoReq& p_req) { + folly::Promise< ::nebula::storage::cpp2::ListClusterInfoResp> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_listClusterInfo, channel_); + listClusterInfo(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture< ::nebula::storage::cpp2::ListClusterInfoResp> StorageAdminServiceAsyncClient::semifuture_listClusterInfo(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::ListClusterInfoReq& p_req) { + auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_listClusterInfo, channel_); + auto callback = std::move(callbackAndFuture.first); + listClusterInfo(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +folly::Future>> StorageAdminServiceAsyncClient::header_future_listClusterInfo(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::ListClusterInfoReq& p_req) { + folly::Promise>> promise; + auto future = promise.getFuture(); + auto callback = std::make_unique>(std::move(promise), recv_wrapped_listClusterInfo, channel_); + listClusterInfo(rpcOptions, std::move(callback), p_req); + return future; +} + +folly::SemiFuture>> StorageAdminServiceAsyncClient::header_semifuture_listClusterInfo(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::ListClusterInfoReq& p_req) { + auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_listClusterInfo, channel_); + auto callback = std::move(callbackAndFuture.first); + listClusterInfo(rpcOptions, std::move(callback), p_req); + return std::move(callbackAndFuture.second); +} + +void StorageAdminServiceAsyncClient::listClusterInfo(folly::Function callback, const ::nebula::storage::cpp2::ListClusterInfoReq& p_req) { + listClusterInfo(std::make_unique(std::move(callback)), p_req); +} + +#if FOLLY_HAS_COROUTINES +#endif // FOLLY_HAS_COROUTINES +folly::exception_wrapper StorageAdminServiceAsyncClient::recv_wrapped_listClusterInfo( ::nebula::storage::cpp2::ListClusterInfoResp& _return, ::apache::thrift::ClientReceiveState& state) { + if (state.isException()) { + return std::move(state.exception()); + } + if (!state.buf()) { + return folly::make_exception_wrapper("recv_ called without result"); + } + + using result = StorageAdminService_listClusterInfo_presult; + constexpr auto const fname = "listClusterInfo"; + switch (state.protocolId()) { + case apache::thrift::protocol::T_BINARY_PROTOCOL: + { + apache::thrift::BinaryProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + case apache::thrift::protocol::T_COMPACT_PROTOCOL: + { + apache::thrift::CompactProtocolReader reader; + return apache::thrift::detail::ac::recv_wrapped( + fname, &reader, state, _return); + } + default: + { + } + } + return folly::make_exception_wrapper("Could not find Protocol"); +} + +void StorageAdminServiceAsyncClient::recv_listClusterInfo( ::nebula::storage::cpp2::ListClusterInfoResp& _return, ::apache::thrift::ClientReceiveState& state) { + auto ew = recv_wrapped_listClusterInfo(_return, state); + if (ew) { + ew.throw_exception(); + } +} + +void StorageAdminServiceAsyncClient::recv_instance_listClusterInfo( ::nebula::storage::cpp2::ListClusterInfoResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_listClusterInfo(_return, state); +} + +folly::exception_wrapper StorageAdminServiceAsyncClient::recv_instance_wrapped_listClusterInfo( ::nebula::storage::cpp2::ListClusterInfoResp& _return, ::apache::thrift::ClientReceiveState& state) { + return recv_wrapped_listClusterInfo(_return, state); +} + + +}}} // nebula::storage::cpp2 diff --git a/src/interface/gen-cpp2/StorageAdminServiceAsyncClient.h b/src/interface/gen-cpp2/StorageAdminServiceAsyncClient.h new file mode 100644 index 00000000..64768da6 --- /dev/null +++ b/src/interface/gen-cpp2/StorageAdminServiceAsyncClient.h @@ -0,0 +1,1346 @@ +/** + * Autogenerated by Thrift for storage.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#pragma once + +#include + +#include "storage_types.h" +#include "common_types.h" +#include "meta_types.h" + +namespace apache { namespace thrift { + class Cpp2RequestContext; + namespace detail { namespace ac { struct ClientRequestContext; }} + namespace transport { class THeader; } +}} + +namespace nebula { namespace storage { namespace cpp2 { + +class StorageAdminServiceAsyncClient : public apache::thrift::GeneratedAsyncClient { + public: + using apache::thrift::GeneratedAsyncClient::GeneratedAsyncClient; + + char const* getServiceName() const noexcept override { + return "StorageAdminService"; + } + + + virtual void transLeader(std::unique_ptr callback, const ::nebula::storage::cpp2::TransLeaderReq& p_req); + virtual void transLeader(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::storage::cpp2::TransLeaderReq& p_req); + protected: + void transLeaderImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::TransLeaderReq& p_req); + public: + + virtual void sync_transLeader( ::nebula::storage::cpp2::AdminExecResp& _return, const ::nebula::storage::cpp2::TransLeaderReq& p_req); + virtual void sync_transLeader(apache::thrift::RpcOptions& rpcOptions, ::nebula::storage::cpp2::AdminExecResp& _return, const ::nebula::storage::cpp2::TransLeaderReq& p_req); + + virtual folly::Future< ::nebula::storage::cpp2::AdminExecResp> future_transLeader(const ::nebula::storage::cpp2::TransLeaderReq& p_req); + virtual folly::SemiFuture< ::nebula::storage::cpp2::AdminExecResp> semifuture_transLeader(const ::nebula::storage::cpp2::TransLeaderReq& p_req); + virtual folly::Future< ::nebula::storage::cpp2::AdminExecResp> future_transLeader(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::TransLeaderReq& p_req); + virtual folly::SemiFuture< ::nebula::storage::cpp2::AdminExecResp> semifuture_transLeader(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::TransLeaderReq& p_req); + virtual folly::Future>> header_future_transLeader(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::TransLeaderReq& p_req); + virtual folly::SemiFuture>> header_semifuture_transLeader(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::TransLeaderReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::storage::cpp2::AdminExecResp> co_transLeader(const ::nebula::storage::cpp2::TransLeaderReq& p_req) { + return co_transLeader(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::storage::cpp2::AdminExecResp> co_transLeader(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::TransLeaderReq& p_req) { + return co_transLeader(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::storage::cpp2::AdminExecResp> co_transLeader(apache::thrift::RpcOptions* rpcOptions, const ::nebula::storage::cpp2::TransLeaderReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = transLeaderCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + transLeaderImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + transLeaderImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::storage::cpp2::AdminExecResp _return; + if (auto ew = recv_wrapped_transLeader(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void transLeader(folly::Function callback, const ::nebula::storage::cpp2::TransLeaderReq& p_req); + + + static folly::exception_wrapper recv_wrapped_transLeader( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_transLeader( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_transLeader( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_transLeader( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void transLeaderT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::TransLeaderReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> transLeaderCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void addPart(std::unique_ptr callback, const ::nebula::storage::cpp2::AddPartReq& p_req); + virtual void addPart(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::storage::cpp2::AddPartReq& p_req); + protected: + void addPartImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::AddPartReq& p_req); + public: + + virtual void sync_addPart( ::nebula::storage::cpp2::AdminExecResp& _return, const ::nebula::storage::cpp2::AddPartReq& p_req); + virtual void sync_addPart(apache::thrift::RpcOptions& rpcOptions, ::nebula::storage::cpp2::AdminExecResp& _return, const ::nebula::storage::cpp2::AddPartReq& p_req); + + virtual folly::Future< ::nebula::storage::cpp2::AdminExecResp> future_addPart(const ::nebula::storage::cpp2::AddPartReq& p_req); + virtual folly::SemiFuture< ::nebula::storage::cpp2::AdminExecResp> semifuture_addPart(const ::nebula::storage::cpp2::AddPartReq& p_req); + virtual folly::Future< ::nebula::storage::cpp2::AdminExecResp> future_addPart(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::AddPartReq& p_req); + virtual folly::SemiFuture< ::nebula::storage::cpp2::AdminExecResp> semifuture_addPart(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::AddPartReq& p_req); + virtual folly::Future>> header_future_addPart(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::AddPartReq& p_req); + virtual folly::SemiFuture>> header_semifuture_addPart(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::AddPartReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::storage::cpp2::AdminExecResp> co_addPart(const ::nebula::storage::cpp2::AddPartReq& p_req) { + return co_addPart(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::storage::cpp2::AdminExecResp> co_addPart(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::AddPartReq& p_req) { + return co_addPart(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::storage::cpp2::AdminExecResp> co_addPart(apache::thrift::RpcOptions* rpcOptions, const ::nebula::storage::cpp2::AddPartReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = addPartCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + addPartImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + addPartImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::storage::cpp2::AdminExecResp _return; + if (auto ew = recv_wrapped_addPart(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void addPart(folly::Function callback, const ::nebula::storage::cpp2::AddPartReq& p_req); + + + static folly::exception_wrapper recv_wrapped_addPart( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_addPart( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_addPart( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_addPart( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void addPartT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::AddPartReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> addPartCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void addLearner(std::unique_ptr callback, const ::nebula::storage::cpp2::AddLearnerReq& p_req); + virtual void addLearner(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::storage::cpp2::AddLearnerReq& p_req); + protected: + void addLearnerImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::AddLearnerReq& p_req); + public: + + virtual void sync_addLearner( ::nebula::storage::cpp2::AdminExecResp& _return, const ::nebula::storage::cpp2::AddLearnerReq& p_req); + virtual void sync_addLearner(apache::thrift::RpcOptions& rpcOptions, ::nebula::storage::cpp2::AdminExecResp& _return, const ::nebula::storage::cpp2::AddLearnerReq& p_req); + + virtual folly::Future< ::nebula::storage::cpp2::AdminExecResp> future_addLearner(const ::nebula::storage::cpp2::AddLearnerReq& p_req); + virtual folly::SemiFuture< ::nebula::storage::cpp2::AdminExecResp> semifuture_addLearner(const ::nebula::storage::cpp2::AddLearnerReq& p_req); + virtual folly::Future< ::nebula::storage::cpp2::AdminExecResp> future_addLearner(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::AddLearnerReq& p_req); + virtual folly::SemiFuture< ::nebula::storage::cpp2::AdminExecResp> semifuture_addLearner(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::AddLearnerReq& p_req); + virtual folly::Future>> header_future_addLearner(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::AddLearnerReq& p_req); + virtual folly::SemiFuture>> header_semifuture_addLearner(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::AddLearnerReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::storage::cpp2::AdminExecResp> co_addLearner(const ::nebula::storage::cpp2::AddLearnerReq& p_req) { + return co_addLearner(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::storage::cpp2::AdminExecResp> co_addLearner(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::AddLearnerReq& p_req) { + return co_addLearner(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::storage::cpp2::AdminExecResp> co_addLearner(apache::thrift::RpcOptions* rpcOptions, const ::nebula::storage::cpp2::AddLearnerReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = addLearnerCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + addLearnerImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + addLearnerImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::storage::cpp2::AdminExecResp _return; + if (auto ew = recv_wrapped_addLearner(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void addLearner(folly::Function callback, const ::nebula::storage::cpp2::AddLearnerReq& p_req); + + + static folly::exception_wrapper recv_wrapped_addLearner( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_addLearner( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_addLearner( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_addLearner( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void addLearnerT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::AddLearnerReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> addLearnerCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void removePart(std::unique_ptr callback, const ::nebula::storage::cpp2::RemovePartReq& p_req); + virtual void removePart(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::storage::cpp2::RemovePartReq& p_req); + protected: + void removePartImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::RemovePartReq& p_req); + public: + + virtual void sync_removePart( ::nebula::storage::cpp2::AdminExecResp& _return, const ::nebula::storage::cpp2::RemovePartReq& p_req); + virtual void sync_removePart(apache::thrift::RpcOptions& rpcOptions, ::nebula::storage::cpp2::AdminExecResp& _return, const ::nebula::storage::cpp2::RemovePartReq& p_req); + + virtual folly::Future< ::nebula::storage::cpp2::AdminExecResp> future_removePart(const ::nebula::storage::cpp2::RemovePartReq& p_req); + virtual folly::SemiFuture< ::nebula::storage::cpp2::AdminExecResp> semifuture_removePart(const ::nebula::storage::cpp2::RemovePartReq& p_req); + virtual folly::Future< ::nebula::storage::cpp2::AdminExecResp> future_removePart(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::RemovePartReq& p_req); + virtual folly::SemiFuture< ::nebula::storage::cpp2::AdminExecResp> semifuture_removePart(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::RemovePartReq& p_req); + virtual folly::Future>> header_future_removePart(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::RemovePartReq& p_req); + virtual folly::SemiFuture>> header_semifuture_removePart(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::RemovePartReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::storage::cpp2::AdminExecResp> co_removePart(const ::nebula::storage::cpp2::RemovePartReq& p_req) { + return co_removePart(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::storage::cpp2::AdminExecResp> co_removePart(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::RemovePartReq& p_req) { + return co_removePart(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::storage::cpp2::AdminExecResp> co_removePart(apache::thrift::RpcOptions* rpcOptions, const ::nebula::storage::cpp2::RemovePartReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = removePartCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + removePartImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + removePartImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::storage::cpp2::AdminExecResp _return; + if (auto ew = recv_wrapped_removePart(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void removePart(folly::Function callback, const ::nebula::storage::cpp2::RemovePartReq& p_req); + + + static folly::exception_wrapper recv_wrapped_removePart( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_removePart( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_removePart( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_removePart( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void removePartT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::RemovePartReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> removePartCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void memberChange(std::unique_ptr callback, const ::nebula::storage::cpp2::MemberChangeReq& p_req); + virtual void memberChange(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::storage::cpp2::MemberChangeReq& p_req); + protected: + void memberChangeImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::MemberChangeReq& p_req); + public: + + virtual void sync_memberChange( ::nebula::storage::cpp2::AdminExecResp& _return, const ::nebula::storage::cpp2::MemberChangeReq& p_req); + virtual void sync_memberChange(apache::thrift::RpcOptions& rpcOptions, ::nebula::storage::cpp2::AdminExecResp& _return, const ::nebula::storage::cpp2::MemberChangeReq& p_req); + + virtual folly::Future< ::nebula::storage::cpp2::AdminExecResp> future_memberChange(const ::nebula::storage::cpp2::MemberChangeReq& p_req); + virtual folly::SemiFuture< ::nebula::storage::cpp2::AdminExecResp> semifuture_memberChange(const ::nebula::storage::cpp2::MemberChangeReq& p_req); + virtual folly::Future< ::nebula::storage::cpp2::AdminExecResp> future_memberChange(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::MemberChangeReq& p_req); + virtual folly::SemiFuture< ::nebula::storage::cpp2::AdminExecResp> semifuture_memberChange(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::MemberChangeReq& p_req); + virtual folly::Future>> header_future_memberChange(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::MemberChangeReq& p_req); + virtual folly::SemiFuture>> header_semifuture_memberChange(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::MemberChangeReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::storage::cpp2::AdminExecResp> co_memberChange(const ::nebula::storage::cpp2::MemberChangeReq& p_req) { + return co_memberChange(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::storage::cpp2::AdminExecResp> co_memberChange(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::MemberChangeReq& p_req) { + return co_memberChange(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::storage::cpp2::AdminExecResp> co_memberChange(apache::thrift::RpcOptions* rpcOptions, const ::nebula::storage::cpp2::MemberChangeReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = memberChangeCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + memberChangeImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + memberChangeImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::storage::cpp2::AdminExecResp _return; + if (auto ew = recv_wrapped_memberChange(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void memberChange(folly::Function callback, const ::nebula::storage::cpp2::MemberChangeReq& p_req); + + + static folly::exception_wrapper recv_wrapped_memberChange( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_memberChange( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_memberChange( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_memberChange( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void memberChangeT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::MemberChangeReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> memberChangeCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void waitingForCatchUpData(std::unique_ptr callback, const ::nebula::storage::cpp2::CatchUpDataReq& p_req); + virtual void waitingForCatchUpData(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::storage::cpp2::CatchUpDataReq& p_req); + protected: + void waitingForCatchUpDataImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::CatchUpDataReq& p_req); + public: + + virtual void sync_waitingForCatchUpData( ::nebula::storage::cpp2::AdminExecResp& _return, const ::nebula::storage::cpp2::CatchUpDataReq& p_req); + virtual void sync_waitingForCatchUpData(apache::thrift::RpcOptions& rpcOptions, ::nebula::storage::cpp2::AdminExecResp& _return, const ::nebula::storage::cpp2::CatchUpDataReq& p_req); + + virtual folly::Future< ::nebula::storage::cpp2::AdminExecResp> future_waitingForCatchUpData(const ::nebula::storage::cpp2::CatchUpDataReq& p_req); + virtual folly::SemiFuture< ::nebula::storage::cpp2::AdminExecResp> semifuture_waitingForCatchUpData(const ::nebula::storage::cpp2::CatchUpDataReq& p_req); + virtual folly::Future< ::nebula::storage::cpp2::AdminExecResp> future_waitingForCatchUpData(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::CatchUpDataReq& p_req); + virtual folly::SemiFuture< ::nebula::storage::cpp2::AdminExecResp> semifuture_waitingForCatchUpData(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::CatchUpDataReq& p_req); + virtual folly::Future>> header_future_waitingForCatchUpData(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::CatchUpDataReq& p_req); + virtual folly::SemiFuture>> header_semifuture_waitingForCatchUpData(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::CatchUpDataReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::storage::cpp2::AdminExecResp> co_waitingForCatchUpData(const ::nebula::storage::cpp2::CatchUpDataReq& p_req) { + return co_waitingForCatchUpData(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::storage::cpp2::AdminExecResp> co_waitingForCatchUpData(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::CatchUpDataReq& p_req) { + return co_waitingForCatchUpData(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::storage::cpp2::AdminExecResp> co_waitingForCatchUpData(apache::thrift::RpcOptions* rpcOptions, const ::nebula::storage::cpp2::CatchUpDataReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = waitingForCatchUpDataCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + waitingForCatchUpDataImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + waitingForCatchUpDataImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::storage::cpp2::AdminExecResp _return; + if (auto ew = recv_wrapped_waitingForCatchUpData(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void waitingForCatchUpData(folly::Function callback, const ::nebula::storage::cpp2::CatchUpDataReq& p_req); + + + static folly::exception_wrapper recv_wrapped_waitingForCatchUpData( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_waitingForCatchUpData( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_waitingForCatchUpData( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_waitingForCatchUpData( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void waitingForCatchUpDataT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::CatchUpDataReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> waitingForCatchUpDataCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void createCheckpoint(std::unique_ptr callback, const ::nebula::storage::cpp2::CreateCPRequest& p_req); + virtual void createCheckpoint(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::storage::cpp2::CreateCPRequest& p_req); + protected: + void createCheckpointImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::CreateCPRequest& p_req); + public: + + virtual void sync_createCheckpoint( ::nebula::storage::cpp2::CreateCPResp& _return, const ::nebula::storage::cpp2::CreateCPRequest& p_req); + virtual void sync_createCheckpoint(apache::thrift::RpcOptions& rpcOptions, ::nebula::storage::cpp2::CreateCPResp& _return, const ::nebula::storage::cpp2::CreateCPRequest& p_req); + + virtual folly::Future< ::nebula::storage::cpp2::CreateCPResp> future_createCheckpoint(const ::nebula::storage::cpp2::CreateCPRequest& p_req); + virtual folly::SemiFuture< ::nebula::storage::cpp2::CreateCPResp> semifuture_createCheckpoint(const ::nebula::storage::cpp2::CreateCPRequest& p_req); + virtual folly::Future< ::nebula::storage::cpp2::CreateCPResp> future_createCheckpoint(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::CreateCPRequest& p_req); + virtual folly::SemiFuture< ::nebula::storage::cpp2::CreateCPResp> semifuture_createCheckpoint(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::CreateCPRequest& p_req); + virtual folly::Future>> header_future_createCheckpoint(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::CreateCPRequest& p_req); + virtual folly::SemiFuture>> header_semifuture_createCheckpoint(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::CreateCPRequest& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::storage::cpp2::CreateCPResp> co_createCheckpoint(const ::nebula::storage::cpp2::CreateCPRequest& p_req) { + return co_createCheckpoint(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::storage::cpp2::CreateCPResp> co_createCheckpoint(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::CreateCPRequest& p_req) { + return co_createCheckpoint(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::storage::cpp2::CreateCPResp> co_createCheckpoint(apache::thrift::RpcOptions* rpcOptions, const ::nebula::storage::cpp2::CreateCPRequest& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = createCheckpointCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + createCheckpointImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + createCheckpointImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::storage::cpp2::CreateCPResp _return; + if (auto ew = recv_wrapped_createCheckpoint(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void createCheckpoint(folly::Function callback, const ::nebula::storage::cpp2::CreateCPRequest& p_req); + + + static folly::exception_wrapper recv_wrapped_createCheckpoint( ::nebula::storage::cpp2::CreateCPResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_createCheckpoint( ::nebula::storage::cpp2::CreateCPResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_createCheckpoint( ::nebula::storage::cpp2::CreateCPResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_createCheckpoint( ::nebula::storage::cpp2::CreateCPResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void createCheckpointT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::CreateCPRequest& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> createCheckpointCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void dropCheckpoint(std::unique_ptr callback, const ::nebula::storage::cpp2::DropCPRequest& p_req); + virtual void dropCheckpoint(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::storage::cpp2::DropCPRequest& p_req); + protected: + void dropCheckpointImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::DropCPRequest& p_req); + public: + + virtual void sync_dropCheckpoint( ::nebula::storage::cpp2::AdminExecResp& _return, const ::nebula::storage::cpp2::DropCPRequest& p_req); + virtual void sync_dropCheckpoint(apache::thrift::RpcOptions& rpcOptions, ::nebula::storage::cpp2::AdminExecResp& _return, const ::nebula::storage::cpp2::DropCPRequest& p_req); + + virtual folly::Future< ::nebula::storage::cpp2::AdminExecResp> future_dropCheckpoint(const ::nebula::storage::cpp2::DropCPRequest& p_req); + virtual folly::SemiFuture< ::nebula::storage::cpp2::AdminExecResp> semifuture_dropCheckpoint(const ::nebula::storage::cpp2::DropCPRequest& p_req); + virtual folly::Future< ::nebula::storage::cpp2::AdminExecResp> future_dropCheckpoint(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::DropCPRequest& p_req); + virtual folly::SemiFuture< ::nebula::storage::cpp2::AdminExecResp> semifuture_dropCheckpoint(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::DropCPRequest& p_req); + virtual folly::Future>> header_future_dropCheckpoint(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::DropCPRequest& p_req); + virtual folly::SemiFuture>> header_semifuture_dropCheckpoint(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::DropCPRequest& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::storage::cpp2::AdminExecResp> co_dropCheckpoint(const ::nebula::storage::cpp2::DropCPRequest& p_req) { + return co_dropCheckpoint(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::storage::cpp2::AdminExecResp> co_dropCheckpoint(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::DropCPRequest& p_req) { + return co_dropCheckpoint(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::storage::cpp2::AdminExecResp> co_dropCheckpoint(apache::thrift::RpcOptions* rpcOptions, const ::nebula::storage::cpp2::DropCPRequest& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = dropCheckpointCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + dropCheckpointImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + dropCheckpointImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::storage::cpp2::AdminExecResp _return; + if (auto ew = recv_wrapped_dropCheckpoint(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void dropCheckpoint(folly::Function callback, const ::nebula::storage::cpp2::DropCPRequest& p_req); + + + static folly::exception_wrapper recv_wrapped_dropCheckpoint( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_dropCheckpoint( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_dropCheckpoint( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_dropCheckpoint( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void dropCheckpointT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::DropCPRequest& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> dropCheckpointCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void blockingWrites(std::unique_ptr callback, const ::nebula::storage::cpp2::BlockingSignRequest& p_req); + virtual void blockingWrites(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::storage::cpp2::BlockingSignRequest& p_req); + protected: + void blockingWritesImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::BlockingSignRequest& p_req); + public: + + virtual void sync_blockingWrites( ::nebula::storage::cpp2::AdminExecResp& _return, const ::nebula::storage::cpp2::BlockingSignRequest& p_req); + virtual void sync_blockingWrites(apache::thrift::RpcOptions& rpcOptions, ::nebula::storage::cpp2::AdminExecResp& _return, const ::nebula::storage::cpp2::BlockingSignRequest& p_req); + + virtual folly::Future< ::nebula::storage::cpp2::AdminExecResp> future_blockingWrites(const ::nebula::storage::cpp2::BlockingSignRequest& p_req); + virtual folly::SemiFuture< ::nebula::storage::cpp2::AdminExecResp> semifuture_blockingWrites(const ::nebula::storage::cpp2::BlockingSignRequest& p_req); + virtual folly::Future< ::nebula::storage::cpp2::AdminExecResp> future_blockingWrites(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::BlockingSignRequest& p_req); + virtual folly::SemiFuture< ::nebula::storage::cpp2::AdminExecResp> semifuture_blockingWrites(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::BlockingSignRequest& p_req); + virtual folly::Future>> header_future_blockingWrites(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::BlockingSignRequest& p_req); + virtual folly::SemiFuture>> header_semifuture_blockingWrites(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::BlockingSignRequest& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::storage::cpp2::AdminExecResp> co_blockingWrites(const ::nebula::storage::cpp2::BlockingSignRequest& p_req) { + return co_blockingWrites(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::storage::cpp2::AdminExecResp> co_blockingWrites(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::BlockingSignRequest& p_req) { + return co_blockingWrites(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::storage::cpp2::AdminExecResp> co_blockingWrites(apache::thrift::RpcOptions* rpcOptions, const ::nebula::storage::cpp2::BlockingSignRequest& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = blockingWritesCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + blockingWritesImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + blockingWritesImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::storage::cpp2::AdminExecResp _return; + if (auto ew = recv_wrapped_blockingWrites(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void blockingWrites(folly::Function callback, const ::nebula::storage::cpp2::BlockingSignRequest& p_req); + + + static folly::exception_wrapper recv_wrapped_blockingWrites( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_blockingWrites( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_blockingWrites( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_blockingWrites( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void blockingWritesT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::BlockingSignRequest& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> blockingWritesCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void rebuildTagIndex(std::unique_ptr callback, const ::nebula::storage::cpp2::RebuildIndexRequest& p_req); + virtual void rebuildTagIndex(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::storage::cpp2::RebuildIndexRequest& p_req); + protected: + void rebuildTagIndexImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::RebuildIndexRequest& p_req); + public: + + virtual void sync_rebuildTagIndex( ::nebula::storage::cpp2::AdminExecResp& _return, const ::nebula::storage::cpp2::RebuildIndexRequest& p_req); + virtual void sync_rebuildTagIndex(apache::thrift::RpcOptions& rpcOptions, ::nebula::storage::cpp2::AdminExecResp& _return, const ::nebula::storage::cpp2::RebuildIndexRequest& p_req); + + virtual folly::Future< ::nebula::storage::cpp2::AdminExecResp> future_rebuildTagIndex(const ::nebula::storage::cpp2::RebuildIndexRequest& p_req); + virtual folly::SemiFuture< ::nebula::storage::cpp2::AdminExecResp> semifuture_rebuildTagIndex(const ::nebula::storage::cpp2::RebuildIndexRequest& p_req); + virtual folly::Future< ::nebula::storage::cpp2::AdminExecResp> future_rebuildTagIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::RebuildIndexRequest& p_req); + virtual folly::SemiFuture< ::nebula::storage::cpp2::AdminExecResp> semifuture_rebuildTagIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::RebuildIndexRequest& p_req); + virtual folly::Future>> header_future_rebuildTagIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::RebuildIndexRequest& p_req); + virtual folly::SemiFuture>> header_semifuture_rebuildTagIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::RebuildIndexRequest& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::storage::cpp2::AdminExecResp> co_rebuildTagIndex(const ::nebula::storage::cpp2::RebuildIndexRequest& p_req) { + return co_rebuildTagIndex(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::storage::cpp2::AdminExecResp> co_rebuildTagIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::RebuildIndexRequest& p_req) { + return co_rebuildTagIndex(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::storage::cpp2::AdminExecResp> co_rebuildTagIndex(apache::thrift::RpcOptions* rpcOptions, const ::nebula::storage::cpp2::RebuildIndexRequest& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = rebuildTagIndexCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + rebuildTagIndexImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + rebuildTagIndexImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::storage::cpp2::AdminExecResp _return; + if (auto ew = recv_wrapped_rebuildTagIndex(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void rebuildTagIndex(folly::Function callback, const ::nebula::storage::cpp2::RebuildIndexRequest& p_req); + + + static folly::exception_wrapper recv_wrapped_rebuildTagIndex( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_rebuildTagIndex( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_rebuildTagIndex( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_rebuildTagIndex( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void rebuildTagIndexT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::RebuildIndexRequest& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> rebuildTagIndexCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void rebuildEdgeIndex(std::unique_ptr callback, const ::nebula::storage::cpp2::RebuildIndexRequest& p_req); + virtual void rebuildEdgeIndex(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::storage::cpp2::RebuildIndexRequest& p_req); + protected: + void rebuildEdgeIndexImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::RebuildIndexRequest& p_req); + public: + + virtual void sync_rebuildEdgeIndex( ::nebula::storage::cpp2::AdminExecResp& _return, const ::nebula::storage::cpp2::RebuildIndexRequest& p_req); + virtual void sync_rebuildEdgeIndex(apache::thrift::RpcOptions& rpcOptions, ::nebula::storage::cpp2::AdminExecResp& _return, const ::nebula::storage::cpp2::RebuildIndexRequest& p_req); + + virtual folly::Future< ::nebula::storage::cpp2::AdminExecResp> future_rebuildEdgeIndex(const ::nebula::storage::cpp2::RebuildIndexRequest& p_req); + virtual folly::SemiFuture< ::nebula::storage::cpp2::AdminExecResp> semifuture_rebuildEdgeIndex(const ::nebula::storage::cpp2::RebuildIndexRequest& p_req); + virtual folly::Future< ::nebula::storage::cpp2::AdminExecResp> future_rebuildEdgeIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::RebuildIndexRequest& p_req); + virtual folly::SemiFuture< ::nebula::storage::cpp2::AdminExecResp> semifuture_rebuildEdgeIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::RebuildIndexRequest& p_req); + virtual folly::Future>> header_future_rebuildEdgeIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::RebuildIndexRequest& p_req); + virtual folly::SemiFuture>> header_semifuture_rebuildEdgeIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::RebuildIndexRequest& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::storage::cpp2::AdminExecResp> co_rebuildEdgeIndex(const ::nebula::storage::cpp2::RebuildIndexRequest& p_req) { + return co_rebuildEdgeIndex(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::storage::cpp2::AdminExecResp> co_rebuildEdgeIndex(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::RebuildIndexRequest& p_req) { + return co_rebuildEdgeIndex(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::storage::cpp2::AdminExecResp> co_rebuildEdgeIndex(apache::thrift::RpcOptions* rpcOptions, const ::nebula::storage::cpp2::RebuildIndexRequest& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = rebuildEdgeIndexCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + rebuildEdgeIndexImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + rebuildEdgeIndexImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::storage::cpp2::AdminExecResp _return; + if (auto ew = recv_wrapped_rebuildEdgeIndex(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void rebuildEdgeIndex(folly::Function callback, const ::nebula::storage::cpp2::RebuildIndexRequest& p_req); + + + static folly::exception_wrapper recv_wrapped_rebuildEdgeIndex( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_rebuildEdgeIndex( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_rebuildEdgeIndex( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_rebuildEdgeIndex( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void rebuildEdgeIndexT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::RebuildIndexRequest& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> rebuildEdgeIndexCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void getLeaderParts(std::unique_ptr callback, const ::nebula::storage::cpp2::GetLeaderReq& p_req); + virtual void getLeaderParts(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::storage::cpp2::GetLeaderReq& p_req); + protected: + void getLeaderPartsImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::GetLeaderReq& p_req); + public: + + virtual void sync_getLeaderParts( ::nebula::storage::cpp2::GetLeaderPartsResp& _return, const ::nebula::storage::cpp2::GetLeaderReq& p_req); + virtual void sync_getLeaderParts(apache::thrift::RpcOptions& rpcOptions, ::nebula::storage::cpp2::GetLeaderPartsResp& _return, const ::nebula::storage::cpp2::GetLeaderReq& p_req); + + virtual folly::Future< ::nebula::storage::cpp2::GetLeaderPartsResp> future_getLeaderParts(const ::nebula::storage::cpp2::GetLeaderReq& p_req); + virtual folly::SemiFuture< ::nebula::storage::cpp2::GetLeaderPartsResp> semifuture_getLeaderParts(const ::nebula::storage::cpp2::GetLeaderReq& p_req); + virtual folly::Future< ::nebula::storage::cpp2::GetLeaderPartsResp> future_getLeaderParts(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::GetLeaderReq& p_req); + virtual folly::SemiFuture< ::nebula::storage::cpp2::GetLeaderPartsResp> semifuture_getLeaderParts(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::GetLeaderReq& p_req); + virtual folly::Future>> header_future_getLeaderParts(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::GetLeaderReq& p_req); + virtual folly::SemiFuture>> header_semifuture_getLeaderParts(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::GetLeaderReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::storage::cpp2::GetLeaderPartsResp> co_getLeaderParts(const ::nebula::storage::cpp2::GetLeaderReq& p_req) { + return co_getLeaderParts(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::storage::cpp2::GetLeaderPartsResp> co_getLeaderParts(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::GetLeaderReq& p_req) { + return co_getLeaderParts(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::storage::cpp2::GetLeaderPartsResp> co_getLeaderParts(apache::thrift::RpcOptions* rpcOptions, const ::nebula::storage::cpp2::GetLeaderReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = getLeaderPartsCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + getLeaderPartsImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + getLeaderPartsImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::storage::cpp2::GetLeaderPartsResp _return; + if (auto ew = recv_wrapped_getLeaderParts(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void getLeaderParts(folly::Function callback, const ::nebula::storage::cpp2::GetLeaderReq& p_req); + + + static folly::exception_wrapper recv_wrapped_getLeaderParts( ::nebula::storage::cpp2::GetLeaderPartsResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_getLeaderParts( ::nebula::storage::cpp2::GetLeaderPartsResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_getLeaderParts( ::nebula::storage::cpp2::GetLeaderPartsResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_getLeaderParts( ::nebula::storage::cpp2::GetLeaderPartsResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void getLeaderPartsT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::GetLeaderReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> getLeaderPartsCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void checkPeers(std::unique_ptr callback, const ::nebula::storage::cpp2::CheckPeersReq& p_req); + virtual void checkPeers(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::storage::cpp2::CheckPeersReq& p_req); + protected: + void checkPeersImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::CheckPeersReq& p_req); + public: + + virtual void sync_checkPeers( ::nebula::storage::cpp2::AdminExecResp& _return, const ::nebula::storage::cpp2::CheckPeersReq& p_req); + virtual void sync_checkPeers(apache::thrift::RpcOptions& rpcOptions, ::nebula::storage::cpp2::AdminExecResp& _return, const ::nebula::storage::cpp2::CheckPeersReq& p_req); + + virtual folly::Future< ::nebula::storage::cpp2::AdminExecResp> future_checkPeers(const ::nebula::storage::cpp2::CheckPeersReq& p_req); + virtual folly::SemiFuture< ::nebula::storage::cpp2::AdminExecResp> semifuture_checkPeers(const ::nebula::storage::cpp2::CheckPeersReq& p_req); + virtual folly::Future< ::nebula::storage::cpp2::AdminExecResp> future_checkPeers(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::CheckPeersReq& p_req); + virtual folly::SemiFuture< ::nebula::storage::cpp2::AdminExecResp> semifuture_checkPeers(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::CheckPeersReq& p_req); + virtual folly::Future>> header_future_checkPeers(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::CheckPeersReq& p_req); + virtual folly::SemiFuture>> header_semifuture_checkPeers(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::CheckPeersReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::storage::cpp2::AdminExecResp> co_checkPeers(const ::nebula::storage::cpp2::CheckPeersReq& p_req) { + return co_checkPeers(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::storage::cpp2::AdminExecResp> co_checkPeers(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::CheckPeersReq& p_req) { + return co_checkPeers(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::storage::cpp2::AdminExecResp> co_checkPeers(apache::thrift::RpcOptions* rpcOptions, const ::nebula::storage::cpp2::CheckPeersReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = checkPeersCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + checkPeersImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + checkPeersImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::storage::cpp2::AdminExecResp _return; + if (auto ew = recv_wrapped_checkPeers(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void checkPeers(folly::Function callback, const ::nebula::storage::cpp2::CheckPeersReq& p_req); + + + static folly::exception_wrapper recv_wrapped_checkPeers( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_checkPeers( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_checkPeers( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_checkPeers( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void checkPeersT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::CheckPeersReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> checkPeersCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void addAdminTask(std::unique_ptr callback, const ::nebula::storage::cpp2::AddAdminTaskRequest& p_req); + virtual void addAdminTask(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::storage::cpp2::AddAdminTaskRequest& p_req); + protected: + void addAdminTaskImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::AddAdminTaskRequest& p_req); + public: + + virtual void sync_addAdminTask( ::nebula::storage::cpp2::AdminExecResp& _return, const ::nebula::storage::cpp2::AddAdminTaskRequest& p_req); + virtual void sync_addAdminTask(apache::thrift::RpcOptions& rpcOptions, ::nebula::storage::cpp2::AdminExecResp& _return, const ::nebula::storage::cpp2::AddAdminTaskRequest& p_req); + + virtual folly::Future< ::nebula::storage::cpp2::AdminExecResp> future_addAdminTask(const ::nebula::storage::cpp2::AddAdminTaskRequest& p_req); + virtual folly::SemiFuture< ::nebula::storage::cpp2::AdminExecResp> semifuture_addAdminTask(const ::nebula::storage::cpp2::AddAdminTaskRequest& p_req); + virtual folly::Future< ::nebula::storage::cpp2::AdminExecResp> future_addAdminTask(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::AddAdminTaskRequest& p_req); + virtual folly::SemiFuture< ::nebula::storage::cpp2::AdminExecResp> semifuture_addAdminTask(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::AddAdminTaskRequest& p_req); + virtual folly::Future>> header_future_addAdminTask(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::AddAdminTaskRequest& p_req); + virtual folly::SemiFuture>> header_semifuture_addAdminTask(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::AddAdminTaskRequest& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::storage::cpp2::AdminExecResp> co_addAdminTask(const ::nebula::storage::cpp2::AddAdminTaskRequest& p_req) { + return co_addAdminTask(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::storage::cpp2::AdminExecResp> co_addAdminTask(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::AddAdminTaskRequest& p_req) { + return co_addAdminTask(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::storage::cpp2::AdminExecResp> co_addAdminTask(apache::thrift::RpcOptions* rpcOptions, const ::nebula::storage::cpp2::AddAdminTaskRequest& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = addAdminTaskCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + addAdminTaskImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + addAdminTaskImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::storage::cpp2::AdminExecResp _return; + if (auto ew = recv_wrapped_addAdminTask(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void addAdminTask(folly::Function callback, const ::nebula::storage::cpp2::AddAdminTaskRequest& p_req); + + + static folly::exception_wrapper recv_wrapped_addAdminTask( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_addAdminTask( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_addAdminTask( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_addAdminTask( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void addAdminTaskT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::AddAdminTaskRequest& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> addAdminTaskCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void stopAdminTask(std::unique_ptr callback, const ::nebula::storage::cpp2::StopAdminTaskRequest& p_req); + virtual void stopAdminTask(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::storage::cpp2::StopAdminTaskRequest& p_req); + protected: + void stopAdminTaskImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::StopAdminTaskRequest& p_req); + public: + + virtual void sync_stopAdminTask( ::nebula::storage::cpp2::AdminExecResp& _return, const ::nebula::storage::cpp2::StopAdminTaskRequest& p_req); + virtual void sync_stopAdminTask(apache::thrift::RpcOptions& rpcOptions, ::nebula::storage::cpp2::AdminExecResp& _return, const ::nebula::storage::cpp2::StopAdminTaskRequest& p_req); + + virtual folly::Future< ::nebula::storage::cpp2::AdminExecResp> future_stopAdminTask(const ::nebula::storage::cpp2::StopAdminTaskRequest& p_req); + virtual folly::SemiFuture< ::nebula::storage::cpp2::AdminExecResp> semifuture_stopAdminTask(const ::nebula::storage::cpp2::StopAdminTaskRequest& p_req); + virtual folly::Future< ::nebula::storage::cpp2::AdminExecResp> future_stopAdminTask(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::StopAdminTaskRequest& p_req); + virtual folly::SemiFuture< ::nebula::storage::cpp2::AdminExecResp> semifuture_stopAdminTask(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::StopAdminTaskRequest& p_req); + virtual folly::Future>> header_future_stopAdminTask(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::StopAdminTaskRequest& p_req); + virtual folly::SemiFuture>> header_semifuture_stopAdminTask(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::StopAdminTaskRequest& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::storage::cpp2::AdminExecResp> co_stopAdminTask(const ::nebula::storage::cpp2::StopAdminTaskRequest& p_req) { + return co_stopAdminTask(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::storage::cpp2::AdminExecResp> co_stopAdminTask(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::StopAdminTaskRequest& p_req) { + return co_stopAdminTask(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::storage::cpp2::AdminExecResp> co_stopAdminTask(apache::thrift::RpcOptions* rpcOptions, const ::nebula::storage::cpp2::StopAdminTaskRequest& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = stopAdminTaskCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + stopAdminTaskImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + stopAdminTaskImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::storage::cpp2::AdminExecResp _return; + if (auto ew = recv_wrapped_stopAdminTask(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void stopAdminTask(folly::Function callback, const ::nebula::storage::cpp2::StopAdminTaskRequest& p_req); + + + static folly::exception_wrapper recv_wrapped_stopAdminTask( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_stopAdminTask( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_stopAdminTask( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_stopAdminTask( ::nebula::storage::cpp2::AdminExecResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void stopAdminTaskT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::StopAdminTaskRequest& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> stopAdminTaskCtx(apache::thrift::RpcOptions* rpcOptions); + public: + virtual void listClusterInfo(std::unique_ptr callback, const ::nebula::storage::cpp2::ListClusterInfoReq& p_req); + virtual void listClusterInfo(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr callback, const ::nebula::storage::cpp2::ListClusterInfoReq& p_req); + protected: + void listClusterInfoImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::ListClusterInfoReq& p_req); + public: + + virtual void sync_listClusterInfo( ::nebula::storage::cpp2::ListClusterInfoResp& _return, const ::nebula::storage::cpp2::ListClusterInfoReq& p_req); + virtual void sync_listClusterInfo(apache::thrift::RpcOptions& rpcOptions, ::nebula::storage::cpp2::ListClusterInfoResp& _return, const ::nebula::storage::cpp2::ListClusterInfoReq& p_req); + + virtual folly::Future< ::nebula::storage::cpp2::ListClusterInfoResp> future_listClusterInfo(const ::nebula::storage::cpp2::ListClusterInfoReq& p_req); + virtual folly::SemiFuture< ::nebula::storage::cpp2::ListClusterInfoResp> semifuture_listClusterInfo(const ::nebula::storage::cpp2::ListClusterInfoReq& p_req); + virtual folly::Future< ::nebula::storage::cpp2::ListClusterInfoResp> future_listClusterInfo(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::ListClusterInfoReq& p_req); + virtual folly::SemiFuture< ::nebula::storage::cpp2::ListClusterInfoResp> semifuture_listClusterInfo(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::ListClusterInfoReq& p_req); + virtual folly::Future>> header_future_listClusterInfo(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::ListClusterInfoReq& p_req); + virtual folly::SemiFuture>> header_semifuture_listClusterInfo(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::ListClusterInfoReq& p_req); + +#if FOLLY_HAS_COROUTINES + template + folly::coro::Task< ::nebula::storage::cpp2::ListClusterInfoResp> co_listClusterInfo(const ::nebula::storage::cpp2::ListClusterInfoReq& p_req) { + return co_listClusterInfo(nullptr, p_req); + } + template + folly::coro::Task< ::nebula::storage::cpp2::ListClusterInfoResp> co_listClusterInfo(apache::thrift::RpcOptions& rpcOptions, const ::nebula::storage::cpp2::ListClusterInfoReq& p_req) { + return co_listClusterInfo(&rpcOptions, p_req); + } + private: + template + folly::coro::Task< ::nebula::storage::cpp2::ListClusterInfoResp> co_listClusterInfo(apache::thrift::RpcOptions* rpcOptions, const ::nebula::storage::cpp2::ListClusterInfoReq& p_req) { + const folly::CancellationToken& cancelToken = + co_await folly::coro::co_current_cancellation_token; + const bool cancellable = cancelToken.canBeCancelled(); + apache::thrift::ClientReceiveState returnState; + apache::thrift::ClientSyncCallback callback(&returnState); + auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId(); + auto ctx = listClusterInfoCtx(rpcOptions); + using CancellableCallback = apache::thrift::CancellableRequestClientCallback; + auto cancellableCallback = cancellable ? CancellableCallback::create(&callback, channel_) : nullptr; + static const apache::thrift::RpcOptions defaultRpcOptions; + auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(cancellableCallback ? (apache::thrift::RequestClientCallback*)cancellableCallback.get() : &callback); + if constexpr (hasRpcOptions) { + listClusterInfoImpl(*rpcOptions, ctx, std::move(wrappedCallback), p_req); + } else { + listClusterInfoImpl(defaultRpcOptions, ctx, std::move(wrappedCallback), p_req); + } + if (cancellable) { + folly::CancellationCallback cb(cancelToken, [&] { CancellableCallback::cancel(std::move(cancellableCallback)); }); + co_await callback.co_waitUntilDone(); + } else { + co_await callback.co_waitUntilDone(); + } + if (returnState.isException()) { + co_yield folly::coro::co_error(std::move(returnState.exception())); + } + returnState.resetProtocolId(protocolId); + returnState.resetCtx(std::shared_ptr(ctx, &ctx->ctx)); + SCOPE_EXIT { + if (hasRpcOptions && returnState.header() && !returnState.header()->getHeaders().empty()) { + rpcOptions->setReadHeaders(returnState.header()->releaseHeaders()); + } + }; + ::nebula::storage::cpp2::ListClusterInfoResp _return; + if (auto ew = recv_wrapped_listClusterInfo(_return, returnState)) { + co_yield folly::coro::co_error(std::move(ew)); + } + co_return _return; + } + public: +#endif // FOLLY_HAS_COROUTINES + + virtual void listClusterInfo(folly::Function callback, const ::nebula::storage::cpp2::ListClusterInfoReq& p_req); + + + static folly::exception_wrapper recv_wrapped_listClusterInfo( ::nebula::storage::cpp2::ListClusterInfoResp& _return, ::apache::thrift::ClientReceiveState& state); + static void recv_listClusterInfo( ::nebula::storage::cpp2::ListClusterInfoResp& _return, ::apache::thrift::ClientReceiveState& state); + // Mock friendly virtual instance method + virtual void recv_instance_listClusterInfo( ::nebula::storage::cpp2::ListClusterInfoResp& _return, ::apache::thrift::ClientReceiveState& state); + virtual folly::exception_wrapper recv_instance_wrapped_listClusterInfo( ::nebula::storage::cpp2::ListClusterInfoResp& _return, ::apache::thrift::ClientReceiveState& state); + private: + template + void listClusterInfoT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr ctx, apache::thrift::RequestClientCallback::Ptr callback, const ::nebula::storage::cpp2::ListClusterInfoReq& p_req); + std::shared_ptr<::apache::thrift::detail::ac::ClientRequestContext> listClusterInfoCtx(apache::thrift::RpcOptions* rpcOptions); + public: +}; + +}}} // nebula::storage::cpp2 diff --git a/src/interface/gen-cpp2/StorageAdminService_custom_protocol.h b/src/interface/gen-cpp2/StorageAdminService_custom_protocol.h new file mode 100644 index 00000000..3240bd6a --- /dev/null +++ b/src/interface/gen-cpp2/StorageAdminService_custom_protocol.h @@ -0,0 +1,19 @@ +/** + * Autogenerated by Thrift for storage.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#pragma once + +/** + * This header file includes the tcc files of the corresponding header file + * and the header files of its dependent types. Include this header file + * only when you need to use custom protocols (e.g. DebugProtocol, + * VirtualProtocol) to read/write thrift structs. + */ + +#include "StorageAdminService.tcc" +#include "storage_types_custom_protocol.h" +#include "common_types_custom_protocol.h" +#include "meta_types_custom_protocol.h" diff --git a/src/interface/gen-cpp2/StorageAdminService_processmap_binary.cpp b/src/interface/gen-cpp2/StorageAdminService_processmap_binary.cpp new file mode 100644 index 00000000..aef0d4c0 --- /dev/null +++ b/src/interface/gen-cpp2/StorageAdminService_processmap_binary.cpp @@ -0,0 +1,12 @@ +/** + * Autogenerated by Thrift for storage.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ + +#include "StorageAdminService.h" +#include "StorageAdminService.tcc" + +namespace nebula { namespace storage { namespace cpp2 { +}}} // nebula::storage::cpp2 diff --git a/src/interface/gen-cpp2/StorageAdminService_processmap_compact.cpp b/src/interface/gen-cpp2/StorageAdminService_processmap_compact.cpp new file mode 100644 index 00000000..aef0d4c0 --- /dev/null +++ b/src/interface/gen-cpp2/StorageAdminService_processmap_compact.cpp @@ -0,0 +1,12 @@ +/** + * Autogenerated by Thrift for storage.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ + +#include "StorageAdminService.h" +#include "StorageAdminService.tcc" + +namespace nebula { namespace storage { namespace cpp2 { +}}} // nebula::storage::cpp2 diff --git a/src/interface/gen-cpp2/common_constants.cpp b/src/interface/gen-cpp2/common_constants.cpp new file mode 100644 index 00000000..ca94b284 --- /dev/null +++ b/src/interface/gen-cpp2/common_constants.cpp @@ -0,0 +1,17 @@ +/** + * Autogenerated by Thrift for common.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ + +#include "common_constants.h" + +#include + + +namespace nebula { namespace cpp2 { + +constexpr char const * const common_constants::version_; + +}} // nebula::cpp2 diff --git a/src/interface/gen-cpp2/common_constants.h b/src/interface/gen-cpp2/common_constants.h new file mode 100644 index 00000000..47520b55 --- /dev/null +++ b/src/interface/gen-cpp2/common_constants.h @@ -0,0 +1,25 @@ +/** + * Autogenerated by Thrift for common.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#pragma once + +#include + +#include "common_types.h" + +namespace nebula { namespace cpp2 { + +struct common_constants { + + static constexpr char const * const version_ = "2.6.0"; + + static constexpr char const * version() { + return version_; + } + +}; + +}} // nebula::cpp2 diff --git a/src/interface/gen-cpp2/common_data.cpp b/src/interface/gen-cpp2/common_data.cpp new file mode 100644 index 00000000..7b217efc --- /dev/null +++ b/src/interface/gen-cpp2/common_data.cpp @@ -0,0 +1,698 @@ +/** + * Autogenerated by Thrift for common.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ + +#include "common_data.h" + +#include + +namespace apache { +namespace thrift { + +const std::array<::nebula::cpp2::NullType, 8> TEnumDataStorage<::nebula::cpp2::NullType>::values = {{ + type::__NULL__, + type::NaN, + type::BAD_DATA, + type::BAD_TYPE, + type::ERR_OVERFLOW, + type::UNKNOWN_PROP, + type::DIV_BY_ZERO, + type::OUT_OF_RANGE, +}}; +const std::array TEnumDataStorage<::nebula::cpp2::NullType>::names = {{ + "__NULL__", + "NaN", + "BAD_DATA", + "BAD_TYPE", + "ERR_OVERFLOW", + "UNKNOWN_PROP", + "DIV_BY_ZERO", + "OUT_OF_RANGE", +}}; + +const std::array<::nebula::cpp2::ErrorCode, 121> TEnumDataStorage<::nebula::cpp2::ErrorCode>::values = {{ + type::SUCCEEDED, + type::E_DISCONNECTED, + type::E_FAIL_TO_CONNECT, + type::E_RPC_FAILURE, + type::E_LEADER_CHANGED, + type::E_SPACE_NOT_FOUND, + type::E_TAG_NOT_FOUND, + type::E_EDGE_NOT_FOUND, + type::E_INDEX_NOT_FOUND, + type::E_EDGE_PROP_NOT_FOUND, + type::E_TAG_PROP_NOT_FOUND, + type::E_ROLE_NOT_FOUND, + type::E_CONFIG_NOT_FOUND, + type::E_GROUP_NOT_FOUND, + type::E_ZONE_NOT_FOUND, + type::E_LISTENER_NOT_FOUND, + type::E_PART_NOT_FOUND, + type::E_KEY_NOT_FOUND, + type::E_USER_NOT_FOUND, + type::E_STATS_NOT_FOUND, + type::E_BACKUP_FAILED, + type::E_BACKUP_EMPTY_TABLE, + type::E_BACKUP_TABLE_FAILED, + type::E_PARTIAL_RESULT, + type::E_REBUILD_INDEX_FAILED, + type::E_INVALID_PASSWORD, + type::E_FAILED_GET_ABS_PATH, + type::E_BAD_USERNAME_PASSWORD, + type::E_SESSION_INVALID, + type::E_SESSION_TIMEOUT, + type::E_SYNTAX_ERROR, + type::E_EXECUTION_ERROR, + type::E_STATEMENT_EMPTY, + type::E_BAD_PERMISSION, + type::E_SEMANTIC_ERROR, + type::E_TOO_MANY_CONNECTIONS, + type::E_PARTIAL_SUCCEEDED, + type::E_NO_HOSTS, + type::E_EXISTED, + type::E_INVALID_HOST, + type::E_UNSUPPORTED, + type::E_NOT_DROP, + type::E_BALANCER_RUNNING, + type::E_CONFIG_IMMUTABLE, + type::E_CONFLICT, + type::E_INVALID_PARM, + type::E_WRONGCLUSTER, + type::E_STORE_FAILURE, + type::E_STORE_SEGMENT_ILLEGAL, + type::E_BAD_BALANCE_PLAN, + type::E_BALANCED, + type::E_NO_RUNNING_BALANCE_PLAN, + type::E_NO_VALID_HOST, + type::E_CORRUPTTED_BALANCE_PLAN, + type::E_NO_INVALID_BALANCE_PLAN, + type::E_IMPROPER_ROLE, + type::E_INVALID_PARTITION_NUM, + type::E_INVALID_REPLICA_FACTOR, + type::E_INVALID_CHARSET, + type::E_INVALID_COLLATE, + type::E_CHARSET_COLLATE_NOT_MATCH, + type::E_SNAPSHOT_FAILURE, + type::E_BLOCK_WRITE_FAILURE, + type::E_REBUILD_INDEX_FAILURE, + type::E_INDEX_WITH_TTL, + type::E_ADD_JOB_FAILURE, + type::E_STOP_JOB_FAILURE, + type::E_SAVE_JOB_FAILURE, + type::E_BALANCER_FAILURE, + type::E_JOB_NOT_FINISHED, + type::E_TASK_REPORT_OUT_DATE, + type::E_JOB_NOT_IN_SPACE, + type::E_INVALID_JOB, + type::E_BACKUP_BUILDING_INDEX, + type::E_BACKUP_SPACE_NOT_FOUND, + type::E_RESTORE_FAILURE, + type::E_SESSION_NOT_FOUND, + type::E_LIST_CLUSTER_FAILURE, + type::E_LIST_CLUSTER_GET_ABS_PATH_FAILURE, + type::E_GET_META_DIR_FAILURE, + type::E_QUERY_NOT_FOUND, + type::E_CONSENSUS_ERROR, + type::E_KEY_HAS_EXISTS, + type::E_DATA_TYPE_MISMATCH, + type::E_INVALID_FIELD_VALUE, + type::E_INVALID_OPERATION, + type::E_NOT_NULLABLE, + type::E_FIELD_UNSET, + type::E_OUT_OF_RANGE, + type::E_ATOMIC_OP_FAILED, + type::E_DATA_CONFLICT_ERROR, + type::E_WRITE_STALLED, + type::E_IMPROPER_DATA_TYPE, + type::E_INVALID_SPACEVIDLEN, + type::E_INVALID_FILTER, + type::E_INVALID_UPDATER, + type::E_INVALID_STORE, + type::E_INVALID_PEER, + type::E_RETRY_EXHAUSTED, + type::E_TRANSFER_LEADER_FAILED, + type::E_INVALID_STAT_TYPE, + type::E_INVALID_VID, + type::E_NO_TRANSFORMED, + type::E_LOAD_META_FAILED, + type::E_FAILED_TO_CHECKPOINT, + type::E_CHECKPOINT_BLOCKED, + type::E_FILTER_OUT, + type::E_INVALID_DATA, + type::E_MUTATE_EDGE_CONFLICT, + type::E_MUTATE_TAG_CONFLICT, + type::E_OUTDATED_LOCK, + type::E_INVALID_TASK_PARA, + type::E_USER_CANCEL, + type::E_TASK_EXECUTION_FAILED, + type::E_PLAN_IS_KILLED, + type::E_NO_TERM, + type::E_OUTDATED_TERM, + type::E_OUTDATED_EDGE, + type::E_WRITE_WRITE_CONFLICT, + type::E_CLIENT_SERVER_INCOMPATIBLE, + type::E_UNKNOWN, +}}; +const std::array TEnumDataStorage<::nebula::cpp2::ErrorCode>::names = {{ + "SUCCEEDED", + "E_DISCONNECTED", + "E_FAIL_TO_CONNECT", + "E_RPC_FAILURE", + "E_LEADER_CHANGED", + "E_SPACE_NOT_FOUND", + "E_TAG_NOT_FOUND", + "E_EDGE_NOT_FOUND", + "E_INDEX_NOT_FOUND", + "E_EDGE_PROP_NOT_FOUND", + "E_TAG_PROP_NOT_FOUND", + "E_ROLE_NOT_FOUND", + "E_CONFIG_NOT_FOUND", + "E_GROUP_NOT_FOUND", + "E_ZONE_NOT_FOUND", + "E_LISTENER_NOT_FOUND", + "E_PART_NOT_FOUND", + "E_KEY_NOT_FOUND", + "E_USER_NOT_FOUND", + "E_STATS_NOT_FOUND", + "E_BACKUP_FAILED", + "E_BACKUP_EMPTY_TABLE", + "E_BACKUP_TABLE_FAILED", + "E_PARTIAL_RESULT", + "E_REBUILD_INDEX_FAILED", + "E_INVALID_PASSWORD", + "E_FAILED_GET_ABS_PATH", + "E_BAD_USERNAME_PASSWORD", + "E_SESSION_INVALID", + "E_SESSION_TIMEOUT", + "E_SYNTAX_ERROR", + "E_EXECUTION_ERROR", + "E_STATEMENT_EMPTY", + "E_BAD_PERMISSION", + "E_SEMANTIC_ERROR", + "E_TOO_MANY_CONNECTIONS", + "E_PARTIAL_SUCCEEDED", + "E_NO_HOSTS", + "E_EXISTED", + "E_INVALID_HOST", + "E_UNSUPPORTED", + "E_NOT_DROP", + "E_BALANCER_RUNNING", + "E_CONFIG_IMMUTABLE", + "E_CONFLICT", + "E_INVALID_PARM", + "E_WRONGCLUSTER", + "E_STORE_FAILURE", + "E_STORE_SEGMENT_ILLEGAL", + "E_BAD_BALANCE_PLAN", + "E_BALANCED", + "E_NO_RUNNING_BALANCE_PLAN", + "E_NO_VALID_HOST", + "E_CORRUPTTED_BALANCE_PLAN", + "E_NO_INVALID_BALANCE_PLAN", + "E_IMPROPER_ROLE", + "E_INVALID_PARTITION_NUM", + "E_INVALID_REPLICA_FACTOR", + "E_INVALID_CHARSET", + "E_INVALID_COLLATE", + "E_CHARSET_COLLATE_NOT_MATCH", + "E_SNAPSHOT_FAILURE", + "E_BLOCK_WRITE_FAILURE", + "E_REBUILD_INDEX_FAILURE", + "E_INDEX_WITH_TTL", + "E_ADD_JOB_FAILURE", + "E_STOP_JOB_FAILURE", + "E_SAVE_JOB_FAILURE", + "E_BALANCER_FAILURE", + "E_JOB_NOT_FINISHED", + "E_TASK_REPORT_OUT_DATE", + "E_JOB_NOT_IN_SPACE", + "E_INVALID_JOB", + "E_BACKUP_BUILDING_INDEX", + "E_BACKUP_SPACE_NOT_FOUND", + "E_RESTORE_FAILURE", + "E_SESSION_NOT_FOUND", + "E_LIST_CLUSTER_FAILURE", + "E_LIST_CLUSTER_GET_ABS_PATH_FAILURE", + "E_GET_META_DIR_FAILURE", + "E_QUERY_NOT_FOUND", + "E_CONSENSUS_ERROR", + "E_KEY_HAS_EXISTS", + "E_DATA_TYPE_MISMATCH", + "E_INVALID_FIELD_VALUE", + "E_INVALID_OPERATION", + "E_NOT_NULLABLE", + "E_FIELD_UNSET", + "E_OUT_OF_RANGE", + "E_ATOMIC_OP_FAILED", + "E_DATA_CONFLICT_ERROR", + "E_WRITE_STALLED", + "E_IMPROPER_DATA_TYPE", + "E_INVALID_SPACEVIDLEN", + "E_INVALID_FILTER", + "E_INVALID_UPDATER", + "E_INVALID_STORE", + "E_INVALID_PEER", + "E_RETRY_EXHAUSTED", + "E_TRANSFER_LEADER_FAILED", + "E_INVALID_STAT_TYPE", + "E_INVALID_VID", + "E_NO_TRANSFORMED", + "E_LOAD_META_FAILED", + "E_FAILED_TO_CHECKPOINT", + "E_CHECKPOINT_BLOCKED", + "E_FILTER_OUT", + "E_INVALID_DATA", + "E_MUTATE_EDGE_CONFLICT", + "E_MUTATE_TAG_CONFLICT", + "E_OUTDATED_LOCK", + "E_INVALID_TASK_PARA", + "E_USER_CANCEL", + "E_TASK_EXECUTION_FAILED", + "E_PLAN_IS_KILLED", + "E_NO_TERM", + "E_OUTDATED_TERM", + "E_OUTDATED_EDGE", + "E_WRITE_WRITE_CONFLICT", + "E_CLIENT_SERVER_INCOMPATIBLE", + "E_UNKNOWN", +}}; + +const std::array<::nebula::cpp2::SchemaID::Type, 2> TEnumDataStorage<::nebula::cpp2::SchemaID::Type>::values = {{ + type::tag_id, + type::edge_type, +}}; +const std::array TEnumDataStorage<::nebula::cpp2::SchemaID::Type>::names = {{ + "tag_id", + "edge_type", +}}; + +const std::array<::nebula::cpp2::Value::Type, 16> TEnumDataStorage<::nebula::cpp2::Value::Type>::values = {{ + type::nVal, + type::bVal, + type::iVal, + type::fVal, + type::sVal, + type::dVal, + type::tVal, + type::dtVal, + type::vVal, + type::eVal, + type::pVal, + type::lVal, + type::mVal, + type::uVal, + type::gVal, + type::ggVal, +}}; +const std::array TEnumDataStorage<::nebula::cpp2::Value::Type>::names = {{ + "nVal", + "bVal", + "iVal", + "fVal", + "sVal", + "dVal", + "tVal", + "dtVal", + "vVal", + "eVal", + "pVal", + "lVal", + "mVal", + "uVal", + "gVal", + "ggVal", +}}; + +const std::array TStructDataStorage<::nebula::cpp2::SchemaID>::fields_names = {{ + "tag_id", + "edge_type", +}}; +const std::array TStructDataStorage<::nebula::cpp2::SchemaID>::fields_ids = {{ + 1, + 2, +}}; +const std::array TStructDataStorage<::nebula::cpp2::SchemaID>::fields_types = {{ + TType::T_I32, + TType::T_I32, +}}; + +const std::array TStructDataStorage<::nebula::cpp2::Date>::fields_names = {{ + "year", + "month", + "day", +}}; +const std::array TStructDataStorage<::nebula::cpp2::Date>::fields_ids = {{ + 1, + 2, + 3, +}}; +const std::array TStructDataStorage<::nebula::cpp2::Date>::fields_types = {{ + TType::T_I16, + TType::T_BYTE, + TType::T_BYTE, +}}; + +const std::array TStructDataStorage<::nebula::cpp2::Time>::fields_names = {{ + "hour", + "minute", + "sec", + "microsec", +}}; +const std::array TStructDataStorage<::nebula::cpp2::Time>::fields_ids = {{ + 1, + 2, + 3, + 4, +}}; +const std::array TStructDataStorage<::nebula::cpp2::Time>::fields_types = {{ + TType::T_BYTE, + TType::T_BYTE, + TType::T_BYTE, + TType::T_I32, +}}; + +const std::array TStructDataStorage<::nebula::cpp2::DateTime>::fields_names = {{ + "year", + "month", + "day", + "hour", + "minute", + "sec", + "microsec", +}}; +const std::array TStructDataStorage<::nebula::cpp2::DateTime>::fields_ids = {{ + 1, + 2, + 3, + 4, + 5, + 6, + 7, +}}; +const std::array TStructDataStorage<::nebula::cpp2::DateTime>::fields_types = {{ + TType::T_I16, + TType::T_BYTE, + TType::T_BYTE, + TType::T_BYTE, + TType::T_BYTE, + TType::T_BYTE, + TType::T_I32, +}}; + +const std::array TStructDataStorage<::nebula::cpp2::Value>::fields_names = {{ + "nVal", + "bVal", + "iVal", + "fVal", + "sVal", + "dVal", + "tVal", + "dtVal", + "vVal", + "eVal", + "pVal", + "lVal", + "mVal", + "uVal", + "gVal", + "ggVal", +}}; +const std::array TStructDataStorage<::nebula::cpp2::Value>::fields_ids = {{ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, +}}; +const std::array TStructDataStorage<::nebula::cpp2::Value>::fields_types = {{ + TType::T_I32, + TType::T_BOOL, + TType::T_I64, + TType::T_DOUBLE, + TType::T_STRING, + TType::T_STRUCT, + TType::T_STRUCT, + TType::T_STRUCT, + TType::T_STRUCT, + TType::T_STRUCT, + TType::T_STRUCT, + TType::T_STRUCT, + TType::T_STRUCT, + TType::T_STRUCT, + TType::T_STRUCT, + TType::T_STRUCT, +}}; + +const std::array TStructDataStorage<::nebula::cpp2::NList>::fields_names = {{ + "values", +}}; +const std::array TStructDataStorage<::nebula::cpp2::NList>::fields_ids = {{ + 1, +}}; +const std::array TStructDataStorage<::nebula::cpp2::NList>::fields_types = {{ + TType::T_LIST, +}}; + +const std::array TStructDataStorage<::nebula::cpp2::NMap>::fields_names = {{ + "kvs", +}}; +const std::array TStructDataStorage<::nebula::cpp2::NMap>::fields_ids = {{ + 1, +}}; +const std::array TStructDataStorage<::nebula::cpp2::NMap>::fields_types = {{ + TType::T_MAP, +}}; + +const std::array TStructDataStorage<::nebula::cpp2::NSet>::fields_names = {{ + "values", +}}; +const std::array TStructDataStorage<::nebula::cpp2::NSet>::fields_ids = {{ + 1, +}}; +const std::array TStructDataStorage<::nebula::cpp2::NSet>::fields_types = {{ + TType::T_SET, +}}; + +const std::array TStructDataStorage<::nebula::cpp2::Row>::fields_names = {{ + "values", +}}; +const std::array TStructDataStorage<::nebula::cpp2::Row>::fields_ids = {{ + 1, +}}; +const std::array TStructDataStorage<::nebula::cpp2::Row>::fields_types = {{ + TType::T_LIST, +}}; + +const std::array TStructDataStorage<::nebula::cpp2::DataSet>::fields_names = {{ + "column_names", + "rows", +}}; +const std::array TStructDataStorage<::nebula::cpp2::DataSet>::fields_ids = {{ + 1, + 2, +}}; +const std::array TStructDataStorage<::nebula::cpp2::DataSet>::fields_types = {{ + TType::T_LIST, + TType::T_LIST, +}}; + +const std::array TStructDataStorage<::nebula::cpp2::Geography>::fields_names = {{ + "wkb", +}}; +const std::array TStructDataStorage<::nebula::cpp2::Geography>::fields_ids = {{ + 1, +}}; +const std::array TStructDataStorage<::nebula::cpp2::Geography>::fields_types = {{ + TType::T_STRING, +}}; + +const std::array TStructDataStorage<::nebula::cpp2::Tag>::fields_names = {{ + "name", + "props", +}}; +const std::array TStructDataStorage<::nebula::cpp2::Tag>::fields_ids = {{ + 1, + 2, +}}; +const std::array TStructDataStorage<::nebula::cpp2::Tag>::fields_types = {{ + TType::T_STRING, + TType::T_MAP, +}}; + +const std::array TStructDataStorage<::nebula::cpp2::Vertex>::fields_names = {{ + "vid", + "tags", +}}; +const std::array TStructDataStorage<::nebula::cpp2::Vertex>::fields_ids = {{ + 1, + 2, +}}; +const std::array TStructDataStorage<::nebula::cpp2::Vertex>::fields_types = {{ + TType::T_STRUCT, + TType::T_LIST, +}}; + +const std::array TStructDataStorage<::nebula::cpp2::Edge>::fields_names = {{ + "src", + "dst", + "type", + "name", + "ranking", + "props", +}}; +const std::array TStructDataStorage<::nebula::cpp2::Edge>::fields_ids = {{ + 1, + 2, + 3, + 4, + 5, + 6, +}}; +const std::array TStructDataStorage<::nebula::cpp2::Edge>::fields_types = {{ + TType::T_STRUCT, + TType::T_STRUCT, + TType::T_I32, + TType::T_STRING, + TType::T_I64, + TType::T_MAP, +}}; + +const std::array TStructDataStorage<::nebula::cpp2::Step>::fields_names = {{ + "dst", + "type", + "name", + "ranking", + "props", +}}; +const std::array TStructDataStorage<::nebula::cpp2::Step>::fields_ids = {{ + 1, + 2, + 3, + 4, + 5, +}}; +const std::array TStructDataStorage<::nebula::cpp2::Step>::fields_types = {{ + TType::T_STRUCT, + TType::T_I32, + TType::T_STRING, + TType::T_I64, + TType::T_MAP, +}}; + +const std::array TStructDataStorage<::nebula::cpp2::Path>::fields_names = {{ + "src", + "steps", +}}; +const std::array TStructDataStorage<::nebula::cpp2::Path>::fields_ids = {{ + 1, + 2, +}}; +const std::array TStructDataStorage<::nebula::cpp2::Path>::fields_types = {{ + TType::T_STRUCT, + TType::T_LIST, +}}; + +const std::array TStructDataStorage<::nebula::cpp2::HostAddr>::fields_names = {{ + "host", + "port", +}}; +const std::array TStructDataStorage<::nebula::cpp2::HostAddr>::fields_ids = {{ + 1, + 2, +}}; +const std::array TStructDataStorage<::nebula::cpp2::HostAddr>::fields_types = {{ + TType::T_STRING, + TType::T_I32, +}}; + +const std::array TStructDataStorage<::nebula::cpp2::KeyValue>::fields_names = {{ + "key", + "value", +}}; +const std::array TStructDataStorage<::nebula::cpp2::KeyValue>::fields_ids = {{ + 1, + 2, +}}; +const std::array TStructDataStorage<::nebula::cpp2::KeyValue>::fields_types = {{ + TType::T_STRING, + TType::T_STRING, +}}; + +const std::array TStructDataStorage<::nebula::cpp2::LogInfo>::fields_names = {{ + "log_id", + "term_id", +}}; +const std::array TStructDataStorage<::nebula::cpp2::LogInfo>::fields_ids = {{ + 1, + 2, +}}; +const std::array TStructDataStorage<::nebula::cpp2::LogInfo>::fields_types = {{ + TType::T_I64, + TType::T_I64, +}}; + +const std::array TStructDataStorage<::nebula::cpp2::DirInfo>::fields_names = {{ + "root", + "data", +}}; +const std::array TStructDataStorage<::nebula::cpp2::DirInfo>::fields_ids = {{ + 1, + 2, +}}; +const std::array TStructDataStorage<::nebula::cpp2::DirInfo>::fields_types = {{ + TType::T_STRING, + TType::T_LIST, +}}; + +const std::array TStructDataStorage<::nebula::cpp2::NodeInfo>::fields_names = {{ + "host", + "dir", +}}; +const std::array TStructDataStorage<::nebula::cpp2::NodeInfo>::fields_ids = {{ + 1, + 2, +}}; +const std::array TStructDataStorage<::nebula::cpp2::NodeInfo>::fields_types = {{ + TType::T_STRUCT, + TType::T_STRUCT, +}}; + +const std::array TStructDataStorage<::nebula::cpp2::PartitionBackupInfo>::fields_names = {{ + "info", +}}; +const std::array TStructDataStorage<::nebula::cpp2::PartitionBackupInfo>::fields_ids = {{ + 1, +}}; +const std::array TStructDataStorage<::nebula::cpp2::PartitionBackupInfo>::fields_types = {{ + TType::T_MAP, +}}; + +const std::array TStructDataStorage<::nebula::cpp2::CheckpointInfo>::fields_names = {{ + "partition_info", + "path", +}}; +const std::array TStructDataStorage<::nebula::cpp2::CheckpointInfo>::fields_ids = {{ + 1, + 2, +}}; +const std::array TStructDataStorage<::nebula::cpp2::CheckpointInfo>::fields_types = {{ + TType::T_STRUCT, + TType::T_STRING, +}}; + +} // namespace thrift +} // namespace apache diff --git a/src/interface/gen-cpp2/common_data.h b/src/interface/gen-cpp2/common_data.h new file mode 100644 index 00000000..3be168b1 --- /dev/null +++ b/src/interface/gen-cpp2/common_data.h @@ -0,0 +1,204 @@ +/** + * Autogenerated by Thrift for common.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#pragma once + +#include + +#include "common_types.h" + +namespace apache { namespace thrift { + +template <> struct TEnumDataStorage<::nebula::cpp2::NullType> { + using type = ::nebula::cpp2::NullType; + static constexpr const std::size_t size = 8; + static const std::array values; + static const std::array names; +}; + +template <> struct TEnumDataStorage<::nebula::cpp2::ErrorCode> { + using type = ::nebula::cpp2::ErrorCode; + static constexpr const std::size_t size = 121; + static const std::array values; + static const std::array names; +}; + +template <> struct TEnumDataStorage<::nebula::cpp2::SchemaID::Type> { + using type = ::nebula::cpp2::SchemaID::Type; + static constexpr const std::size_t size = 2; + static const std::array values; + static const std::array names; +}; + +template <> struct TEnumDataStorage<::nebula::cpp2::Value::Type> { + using type = ::nebula::cpp2::Value::Type; + static constexpr const std::size_t size = 16; + static const std::array values; + static const std::array names; +}; + +template <> struct TStructDataStorage<::nebula::cpp2::SchemaID> { + static constexpr const std::size_t fields_size = 2; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::cpp2::Date> { + static constexpr const std::size_t fields_size = 3; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::cpp2::Time> { + static constexpr const std::size_t fields_size = 4; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::cpp2::DateTime> { + static constexpr const std::size_t fields_size = 7; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::cpp2::Value> { + static constexpr const std::size_t fields_size = 16; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::cpp2::NList> { + static constexpr const std::size_t fields_size = 1; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::cpp2::NMap> { + static constexpr const std::size_t fields_size = 1; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::cpp2::NSet> { + static constexpr const std::size_t fields_size = 1; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::cpp2::Row> { + static constexpr const std::size_t fields_size = 1; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::cpp2::DataSet> { + static constexpr const std::size_t fields_size = 2; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::cpp2::Geography> { + static constexpr const std::size_t fields_size = 1; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::cpp2::Tag> { + static constexpr const std::size_t fields_size = 2; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::cpp2::Vertex> { + static constexpr const std::size_t fields_size = 2; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::cpp2::Edge> { + static constexpr const std::size_t fields_size = 6; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::cpp2::Step> { + static constexpr const std::size_t fields_size = 5; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::cpp2::Path> { + static constexpr const std::size_t fields_size = 2; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::cpp2::HostAddr> { + static constexpr const std::size_t fields_size = 2; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::cpp2::KeyValue> { + static constexpr const std::size_t fields_size = 2; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::cpp2::LogInfo> { + static constexpr const std::size_t fields_size = 2; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::cpp2::DirInfo> { + static constexpr const std::size_t fields_size = 2; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::cpp2::NodeInfo> { + static constexpr const std::size_t fields_size = 2; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::cpp2::PartitionBackupInfo> { + static constexpr const std::size_t fields_size = 1; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::cpp2::CheckpointInfo> { + static constexpr const std::size_t fields_size = 2; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +}} // apache::thrift diff --git a/src/interface/gen-cpp2/common_for_each_field.h b/src/interface/gen-cpp2/common_for_each_field.h new file mode 100644 index 00000000..73197be3 --- /dev/null +++ b/src/interface/gen-cpp2/common_for_each_field.h @@ -0,0 +1,247 @@ +/** + * Autogenerated by Thrift for common.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#pragma once + +#include "common_metadata.h" +#include + +namespace apache { +namespace thrift { +namespace detail { + +template <> +struct ForEachField<::nebula::cpp2::SchemaID> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).tag_id_ref()...); + f(1, static_cast(t).edge_type_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::cpp2::Date> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).year_ref()...); + f(1, static_cast(t).month_ref()...); + f(2, static_cast(t).day_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::cpp2::Time> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).hour_ref()...); + f(1, static_cast(t).minute_ref()...); + f(2, static_cast(t).sec_ref()...); + f(3, static_cast(t).microsec_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::cpp2::DateTime> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).year_ref()...); + f(1, static_cast(t).month_ref()...); + f(2, static_cast(t).day_ref()...); + f(3, static_cast(t).hour_ref()...); + f(4, static_cast(t).minute_ref()...); + f(5, static_cast(t).sec_ref()...); + f(6, static_cast(t).microsec_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::cpp2::Value> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).nVal_ref()...); + f(1, static_cast(t).bVal_ref()...); + f(2, static_cast(t).iVal_ref()...); + f(3, static_cast(t).fVal_ref()...); + f(4, static_cast(t).sVal_ref()...); + f(5, static_cast(t).dVal_ref()...); + f(6, static_cast(t).tVal_ref()...); + f(7, static_cast(t).dtVal_ref()...); + f(8, static_cast(t).vVal_ref()...); + f(9, static_cast(t).eVal_ref()...); + f(10, static_cast(t).pVal_ref()...); + f(11, static_cast(t).lVal_ref()...); + f(12, static_cast(t).mVal_ref()...); + f(13, static_cast(t).uVal_ref()...); + f(14, static_cast(t).gVal_ref()...); + f(15, static_cast(t).ggVal_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::cpp2::NList> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).values_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::cpp2::NMap> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).kvs_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::cpp2::NSet> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).values_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::cpp2::Row> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).values_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::cpp2::DataSet> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).column_names_ref()...); + f(1, static_cast(t).rows_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::cpp2::Geography> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).wkb_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::cpp2::Tag> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).name_ref()...); + f(1, static_cast(t).props_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::cpp2::Vertex> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).vid_ref()...); + f(1, static_cast(t).tags_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::cpp2::Edge> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).src_ref()...); + f(1, static_cast(t).dst_ref()...); + f(2, static_cast(t).type_ref()...); + f(3, static_cast(t).name_ref()...); + f(4, static_cast(t).ranking_ref()...); + f(5, static_cast(t).props_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::cpp2::Step> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).dst_ref()...); + f(1, static_cast(t).type_ref()...); + f(2, static_cast(t).name_ref()...); + f(3, static_cast(t).ranking_ref()...); + f(4, static_cast(t).props_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::cpp2::Path> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).src_ref()...); + f(1, static_cast(t).steps_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::cpp2::HostAddr> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).host_ref()...); + f(1, static_cast(t).port_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::cpp2::KeyValue> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).key_ref()...); + f(1, static_cast(t).value_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::cpp2::LogInfo> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).log_id_ref()...); + f(1, static_cast(t).term_id_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::cpp2::DirInfo> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).root_ref()...); + f(1, static_cast(t).data_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::cpp2::NodeInfo> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).host_ref()...); + f(1, static_cast(t).dir_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::cpp2::PartitionBackupInfo> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).info_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::cpp2::CheckpointInfo> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).partition_info_ref()...); + f(1, static_cast(t).path_ref()...); + } +}; +} // namespace detail +} // namespace thrift +} // namespace apache diff --git a/src/interface/gen-cpp2/common_metadata.cpp b/src/interface/gen-cpp2/common_metadata.cpp new file mode 100644 index 00000000..971c4cf3 --- /dev/null +++ b/src/interface/gen-cpp2/common_metadata.cpp @@ -0,0 +1,648 @@ +/** + * Autogenerated by Thrift for common.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#include +#include "common_metadata.h" + +namespace apache { +namespace thrift { +namespace detail { +namespace md { +using ThriftMetadata = ::apache::thrift::metadata::ThriftMetadata; +using ThriftPrimitiveType = ::apache::thrift::metadata::ThriftPrimitiveType; +using ThriftType = ::apache::thrift::metadata::ThriftType; +using ThriftService = ::apache::thrift::metadata::ThriftService; +using ThriftServiceContext = ::apache::thrift::metadata::ThriftServiceContext; +using ThriftFunctionGenerator = void (*)(ThriftMetadata&, ThriftService&); + +void EnumMetadata<::nebula::cpp2::NullType>::gen(ThriftMetadata& metadata) { + auto res = metadata.enums_ref()->emplace("common.NullType", ::apache::thrift::metadata::ThriftEnum{}); + if (!res.second) { + return; + } + ::apache::thrift::metadata::ThriftEnum& enum_metadata = res.first->second; + enum_metadata.name_ref() = "common.NullType"; + using EnumTraits = TEnumTraits<::nebula::cpp2::NullType>; + for (std::size_t i = 0; i < EnumTraits::size; ++i) { + enum_metadata.elements_ref()->emplace(static_cast(EnumTraits::values[i]), EnumTraits::names[i].str()); + } +} +void EnumMetadata<::nebula::cpp2::ErrorCode>::gen(ThriftMetadata& metadata) { + auto res = metadata.enums_ref()->emplace("common.ErrorCode", ::apache::thrift::metadata::ThriftEnum{}); + if (!res.second) { + return; + } + ::apache::thrift::metadata::ThriftEnum& enum_metadata = res.first->second; + enum_metadata.name_ref() = "common.ErrorCode"; + using EnumTraits = TEnumTraits<::nebula::cpp2::ErrorCode>; + for (std::size_t i = 0; i < EnumTraits::size; ++i) { + enum_metadata.elements_ref()->emplace(static_cast(EnumTraits::values[i]), EnumTraits::names[i].str()); + } +} + +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::cpp2::SchemaID>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("common.SchemaID", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& common_SchemaID = res.first->second; + common_SchemaID.name_ref() = "common.SchemaID"; + common_SchemaID.is_union_ref() = true; + static const EncodedThriftField + common_SchemaID_fields[] = { + std::make_tuple(1, "tag_id", false, std::make_unique("common.TagID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + std::make_tuple(2, "edge_type", false, std::make_unique("common.EdgeType", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + }; + for (const auto& f : common_SchemaID_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + common_SchemaID.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::cpp2::Date>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("common.Date", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& common_Date = res.first->second; + common_Date.name_ref() = "common.Date"; + common_Date.is_union_ref() = false; + static const EncodedThriftField + common_Date_fields[] = { + std::make_tuple(1, "year", false, std::make_unique(ThriftPrimitiveType::THRIFT_I16_TYPE), std::vector{}), + std::make_tuple(2, "month", false, std::make_unique(ThriftPrimitiveType::THRIFT_BYTE_TYPE), std::vector{}), + std::make_tuple(3, "day", false, std::make_unique(ThriftPrimitiveType::THRIFT_BYTE_TYPE), std::vector{}), + }; + for (const auto& f : common_Date_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + common_Date.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::cpp2::Time>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("common.Time", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& common_Time = res.first->second; + common_Time.name_ref() = "common.Time"; + common_Time.is_union_ref() = false; + static const EncodedThriftField + common_Time_fields[] = { + std::make_tuple(1, "hour", false, std::make_unique(ThriftPrimitiveType::THRIFT_BYTE_TYPE), std::vector{}), + std::make_tuple(2, "minute", false, std::make_unique(ThriftPrimitiveType::THRIFT_BYTE_TYPE), std::vector{}), + std::make_tuple(3, "sec", false, std::make_unique(ThriftPrimitiveType::THRIFT_BYTE_TYPE), std::vector{}), + std::make_tuple(4, "microsec", false, std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE), std::vector{}), + }; + for (const auto& f : common_Time_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + common_Time.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::cpp2::DateTime>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("common.DateTime", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& common_DateTime = res.first->second; + common_DateTime.name_ref() = "common.DateTime"; + common_DateTime.is_union_ref() = false; + static const EncodedThriftField + common_DateTime_fields[] = { + std::make_tuple(1, "year", false, std::make_unique(ThriftPrimitiveType::THRIFT_I16_TYPE), std::vector{}), + std::make_tuple(2, "month", false, std::make_unique(ThriftPrimitiveType::THRIFT_BYTE_TYPE), std::vector{}), + std::make_tuple(3, "day", false, std::make_unique(ThriftPrimitiveType::THRIFT_BYTE_TYPE), std::vector{}), + std::make_tuple(4, "hour", false, std::make_unique(ThriftPrimitiveType::THRIFT_BYTE_TYPE), std::vector{}), + std::make_tuple(5, "minute", false, std::make_unique(ThriftPrimitiveType::THRIFT_BYTE_TYPE), std::vector{}), + std::make_tuple(6, "sec", false, std::make_unique(ThriftPrimitiveType::THRIFT_BYTE_TYPE), std::vector{}), + std::make_tuple(7, "microsec", false, std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE), std::vector{}), + }; + for (const auto& f : common_DateTime_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + common_DateTime.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::cpp2::Value>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("common.Value", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& common_Value = res.first->second; + common_Value.name_ref() = "common.Value"; + common_Value.is_union_ref() = true; + static const EncodedThriftField + common_Value_fields[] = { + std::make_tuple(1, "nVal", false, std::make_unique>("common.NullType"), std::vector{}), + std::make_tuple(2, "bVal", false, std::make_unique(ThriftPrimitiveType::THRIFT_BOOL_TYPE), std::vector{}), + std::make_tuple(3, "iVal", false, std::make_unique(ThriftPrimitiveType::THRIFT_I64_TYPE), std::vector{}), + std::make_tuple(4, "fVal", false, std::make_unique(ThriftPrimitiveType::THRIFT_DOUBLE_TYPE), std::vector{}), + std::make_tuple(5, "sVal", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + std::make_tuple(6, "dVal", false, std::make_unique>("common.Date"), std::vector{}), + std::make_tuple(7, "tVal", false, std::make_unique>("common.Time"), std::vector{}), + std::make_tuple(8, "dtVal", false, std::make_unique>("common.DateTime"), std::vector{}), + std::make_tuple(9, "vVal", false, std::make_unique("common.Vertex", std::make_unique>("common.Vertex")), std::vector{}), + std::make_tuple(10, "eVal", false, std::make_unique("common.Edge", std::make_unique>("common.Edge")), std::vector{}), + std::make_tuple(11, "pVal", false, std::make_unique("common.Path", std::make_unique>("common.Path")), std::vector{}), + std::make_tuple(12, "lVal", false, std::make_unique("common.NList", std::make_unique>("common.NList")), std::vector{}), + std::make_tuple(13, "mVal", false, std::make_unique("common.NMap", std::make_unique>("common.NMap")), std::vector{}), + std::make_tuple(14, "uVal", false, std::make_unique("common.NSet", std::make_unique>("common.NSet")), std::vector{}), + std::make_tuple(15, "gVal", false, std::make_unique("common.DataSet", std::make_unique>("common.DataSet")), std::vector{}), + std::make_tuple(16, "ggVal", false, std::make_unique("common.Geography", std::make_unique>("common.Geography")), std::vector{}), + }; + for (const auto& f : common_Value_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + common_Value.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::cpp2::NList>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("common.NList", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& common_NList = res.first->second; + common_NList.name_ref() = "common.NList"; + common_NList.is_union_ref() = false; + static const EncodedThriftField + common_NList_fields[] = { + std::make_tuple(1, "values", false, std::make_unique(std::make_unique>("common.Value")), std::vector{}), + }; + for (const auto& f : common_NList_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + common_NList.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::cpp2::NMap>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("common.NMap", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& common_NMap = res.first->second; + common_NMap.name_ref() = "common.NMap"; + common_NMap.is_union_ref() = false; + static const EncodedThriftField + common_NMap_fields[] = { + std::make_tuple(1, "kvs", false, std::make_unique(std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::make_unique>("common.Value")), std::vector{}), + }; + for (const auto& f : common_NMap_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + common_NMap.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::cpp2::NSet>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("common.NSet", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& common_NSet = res.first->second; + common_NSet.name_ref() = "common.NSet"; + common_NSet.is_union_ref() = false; + static const EncodedThriftField + common_NSet_fields[] = { + std::make_tuple(1, "values", false, std::make_unique(std::make_unique>("common.Value")), std::vector{}), + }; + for (const auto& f : common_NSet_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + common_NSet.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::cpp2::Row>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("common.Row", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& common_Row = res.first->second; + common_Row.name_ref() = "common.Row"; + common_Row.is_union_ref() = false; + static const EncodedThriftField + common_Row_fields[] = { + std::make_tuple(1, "values", false, std::make_unique(std::make_unique>("common.Value")), std::vector{}), + }; + for (const auto& f : common_Row_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + common_Row.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::cpp2::DataSet>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("common.DataSet", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& common_DataSet = res.first->second; + common_DataSet.name_ref() = "common.DataSet"; + common_DataSet.is_union_ref() = false; + static const EncodedThriftField + common_DataSet_fields[] = { + std::make_tuple(1, "column_names", false, std::make_unique(std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE)), std::vector{}), + std::make_tuple(2, "rows", false, std::make_unique(std::make_unique>("common.Row")), std::vector{}), + }; + for (const auto& f : common_DataSet_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + common_DataSet.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::cpp2::Geography>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("common.Geography", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& common_Geography = res.first->second; + common_Geography.name_ref() = "common.Geography"; + common_Geography.is_union_ref() = false; + static const EncodedThriftField + common_Geography_fields[] = { + std::make_tuple(1, "wkb", false, std::make_unique(ThriftPrimitiveType::THRIFT_STRING_TYPE), std::vector{}), + }; + for (const auto& f : common_Geography_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + common_Geography.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::cpp2::Tag>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("common.Tag", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& common_Tag = res.first->second; + common_Tag.name_ref() = "common.Tag"; + common_Tag.is_union_ref() = false; + static const EncodedThriftField + common_Tag_fields[] = { + std::make_tuple(1, "name", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + std::make_tuple(2, "props", false, std::make_unique(std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::make_unique>("common.Value")), std::vector{}), + }; + for (const auto& f : common_Tag_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + common_Tag.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::cpp2::Vertex>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("common.Vertex", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& common_Vertex = res.first->second; + common_Vertex.name_ref() = "common.Vertex"; + common_Vertex.is_union_ref() = false; + static const EncodedThriftField + common_Vertex_fields[] = { + std::make_tuple(1, "vid", false, std::make_unique>("common.Value"), std::vector{}), + std::make_tuple(2, "tags", false, std::make_unique(std::make_unique>("common.Tag")), std::vector{}), + }; + for (const auto& f : common_Vertex_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + common_Vertex.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::cpp2::Edge>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("common.Edge", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& common_Edge = res.first->second; + common_Edge.name_ref() = "common.Edge"; + common_Edge.is_union_ref() = false; + static const EncodedThriftField + common_Edge_fields[] = { + std::make_tuple(1, "src", false, std::make_unique>("common.Value"), std::vector{}), + std::make_tuple(2, "dst", false, std::make_unique>("common.Value"), std::vector{}), + std::make_tuple(3, "type", false, std::make_unique("common.EdgeType", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + std::make_tuple(4, "name", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + std::make_tuple(5, "ranking", false, std::make_unique("common.EdgeRanking", std::make_unique(ThriftPrimitiveType::THRIFT_I64_TYPE)), std::vector{}), + std::make_tuple(6, "props", false, std::make_unique(std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::make_unique>("common.Value")), std::vector{}), + }; + for (const auto& f : common_Edge_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + common_Edge.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::cpp2::Step>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("common.Step", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& common_Step = res.first->second; + common_Step.name_ref() = "common.Step"; + common_Step.is_union_ref() = false; + static const EncodedThriftField + common_Step_fields[] = { + std::make_tuple(1, "dst", false, std::make_unique>("common.Vertex"), std::vector{}), + std::make_tuple(2, "type", false, std::make_unique("common.EdgeType", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + std::make_tuple(3, "name", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + std::make_tuple(4, "ranking", false, std::make_unique("common.EdgeRanking", std::make_unique(ThriftPrimitiveType::THRIFT_I64_TYPE)), std::vector{}), + std::make_tuple(5, "props", false, std::make_unique(std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::make_unique>("common.Value")), std::vector{}), + }; + for (const auto& f : common_Step_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + common_Step.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::cpp2::Path>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("common.Path", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& common_Path = res.first->second; + common_Path.name_ref() = "common.Path"; + common_Path.is_union_ref() = false; + static const EncodedThriftField + common_Path_fields[] = { + std::make_tuple(1, "src", false, std::make_unique>("common.Vertex"), std::vector{}), + std::make_tuple(2, "steps", false, std::make_unique(std::make_unique>("common.Step")), std::vector{}), + }; + for (const auto& f : common_Path_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + common_Path.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::cpp2::HostAddr>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("common.HostAddr", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& common_HostAddr = res.first->second; + common_HostAddr.name_ref() = "common.HostAddr"; + common_HostAddr.is_union_ref() = false; + static const EncodedThriftField + common_HostAddr_fields[] = { + std::make_tuple(1, "host", false, std::make_unique(ThriftPrimitiveType::THRIFT_STRING_TYPE), std::vector{}), + std::make_tuple(2, "port", false, std::make_unique("common.Port", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + }; + for (const auto& f : common_HostAddr_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + common_HostAddr.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::cpp2::KeyValue>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("common.KeyValue", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& common_KeyValue = res.first->second; + common_KeyValue.name_ref() = "common.KeyValue"; + common_KeyValue.is_union_ref() = false; + static const EncodedThriftField + common_KeyValue_fields[] = { + std::make_tuple(1, "key", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + std::make_tuple(2, "value", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + }; + for (const auto& f : common_KeyValue_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + common_KeyValue.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::cpp2::LogInfo>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("common.LogInfo", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& common_LogInfo = res.first->second; + common_LogInfo.name_ref() = "common.LogInfo"; + common_LogInfo.is_union_ref() = false; + static const EncodedThriftField + common_LogInfo_fields[] = { + std::make_tuple(1, "log_id", false, std::make_unique("common.LogID", std::make_unique(ThriftPrimitiveType::THRIFT_I64_TYPE)), std::vector{}), + std::make_tuple(2, "term_id", false, std::make_unique("common.TermID", std::make_unique(ThriftPrimitiveType::THRIFT_I64_TYPE)), std::vector{}), + }; + for (const auto& f : common_LogInfo_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + common_LogInfo.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::cpp2::DirInfo>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("common.DirInfo", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& common_DirInfo = res.first->second; + common_DirInfo.name_ref() = "common.DirInfo"; + common_DirInfo.is_union_ref() = false; + static const EncodedThriftField + common_DirInfo_fields[] = { + std::make_tuple(1, "root", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + std::make_tuple(2, "data", false, std::make_unique(std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE)), std::vector{}), + }; + for (const auto& f : common_DirInfo_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + common_DirInfo.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::cpp2::NodeInfo>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("common.NodeInfo", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& common_NodeInfo = res.first->second; + common_NodeInfo.name_ref() = "common.NodeInfo"; + common_NodeInfo.is_union_ref() = false; + static const EncodedThriftField + common_NodeInfo_fields[] = { + std::make_tuple(1, "host", false, std::make_unique>("common.HostAddr"), std::vector{}), + std::make_tuple(2, "dir", false, std::make_unique>("common.DirInfo"), std::vector{}), + }; + for (const auto& f : common_NodeInfo_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + common_NodeInfo.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::cpp2::PartitionBackupInfo>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("common.PartitionBackupInfo", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& common_PartitionBackupInfo = res.first->second; + common_PartitionBackupInfo.name_ref() = "common.PartitionBackupInfo"; + common_PartitionBackupInfo.is_union_ref() = false; + static const EncodedThriftField + common_PartitionBackupInfo_fields[] = { + std::make_tuple(1, "info", false, std::make_unique(std::make_unique("common.PartitionID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::make_unique>("common.LogInfo")), std::vector{}), + }; + for (const auto& f : common_PartitionBackupInfo_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + common_PartitionBackupInfo.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::cpp2::CheckpointInfo>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("common.CheckpointInfo", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& common_CheckpointInfo = res.first->second; + common_CheckpointInfo.name_ref() = "common.CheckpointInfo"; + common_CheckpointInfo.is_union_ref() = false; + static const EncodedThriftField + common_CheckpointInfo_fields[] = { + std::make_tuple(1, "partition_info", false, std::make_unique>("common.PartitionBackupInfo"), std::vector{}), + std::make_tuple(2, "path", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + }; + for (const auto& f : common_CheckpointInfo_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + common_CheckpointInfo.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} + +} // namespace md +} // namespace detail +} // namespace thrift +} // namespace apache diff --git a/src/interface/gen-cpp2/common_metadata.h b/src/interface/gen-cpp2/common_metadata.h new file mode 100644 index 00000000..3893c515 --- /dev/null +++ b/src/interface/gen-cpp2/common_metadata.h @@ -0,0 +1,146 @@ +/** + * Autogenerated by Thrift for common.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#pragma once + +#include +#include "common_types.h" + + +namespace apache { +namespace thrift { +namespace detail { +namespace md { + +template <> +class EnumMetadata<::nebula::cpp2::NullType> { + public: + static void gen(ThriftMetadata& metadata); +}; +template <> +class EnumMetadata<::nebula::cpp2::ErrorCode> { + public: + static void gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::cpp2::SchemaID> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::cpp2::Date> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::cpp2::Time> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::cpp2::DateTime> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::cpp2::Value> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::cpp2::NList> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::cpp2::NMap> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::cpp2::NSet> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::cpp2::Row> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::cpp2::DataSet> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::cpp2::Geography> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::cpp2::Tag> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::cpp2::Vertex> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::cpp2::Edge> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::cpp2::Step> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::cpp2::Path> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::cpp2::HostAddr> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::cpp2::KeyValue> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::cpp2::LogInfo> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::cpp2::DirInfo> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::cpp2::NodeInfo> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::cpp2::PartitionBackupInfo> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::cpp2::CheckpointInfo> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +} // namespace md +} // namespace detail +} // namespace thrift +} // namespace apache diff --git a/src/interface/gen-cpp2/common_types.cpp b/src/interface/gen-cpp2/common_types.cpp new file mode 100644 index 00000000..3242ba17 --- /dev/null +++ b/src/interface/gen-cpp2/common_types.cpp @@ -0,0 +1,2809 @@ +/** + * Autogenerated by Thrift for common.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#include "common_types.h" +#include "common_types.tcc" + +#include + +#include "common_data.h" + + +namespace apache { namespace thrift { + +constexpr std::size_t const TEnumTraits<::nebula::cpp2::NullType>::size; +folly::Range<::nebula::cpp2::NullType const*> const TEnumTraits<::nebula::cpp2::NullType>::values = folly::range(TEnumDataStorage<::nebula::cpp2::NullType>::values); +folly::Range const TEnumTraits<::nebula::cpp2::NullType>::names = folly::range(TEnumDataStorage<::nebula::cpp2::NullType>::names); + +char const* TEnumTraits<::nebula::cpp2::NullType>::findName(type value) { + using factory = ::nebula::cpp2::_NullType_EnumMapFactory; + static folly::Indestructible const map{ + factory::makeValuesToNamesMap()}; + auto found = map->find(value); + return found == map->end() ? nullptr : found->second; +} + +bool TEnumTraits<::nebula::cpp2::NullType>::findValue(char const* name, type* out) { + using factory = ::nebula::cpp2::_NullType_EnumMapFactory; + static folly::Indestructible const map{ + factory::makeNamesToValuesMap()}; + auto found = map->find(name); + return found == map->end() ? false : (*out = found->second, true); +} + +}} // apache::thrift + +namespace nebula { namespace cpp2 { +FOLLY_PUSH_WARNING +FOLLY_GNU_DISABLE_WARNING("-Wdeprecated-declarations") +const _NullType_EnumMapFactory::ValuesToNamesMapType _NullType_VALUES_TO_NAMES = _NullType_EnumMapFactory::makeValuesToNamesMap(); +const _NullType_EnumMapFactory::NamesToValuesMapType _NullType_NAMES_TO_VALUES = _NullType_EnumMapFactory::makeNamesToValuesMap(); +FOLLY_POP_WARNING + +}} // nebula::cpp2 + +namespace apache { namespace thrift { + +constexpr std::size_t const TEnumTraits<::nebula::cpp2::ErrorCode>::size; +folly::Range<::nebula::cpp2::ErrorCode const*> const TEnumTraits<::nebula::cpp2::ErrorCode>::values = folly::range(TEnumDataStorage<::nebula::cpp2::ErrorCode>::values); +folly::Range const TEnumTraits<::nebula::cpp2::ErrorCode>::names = folly::range(TEnumDataStorage<::nebula::cpp2::ErrorCode>::names); + +char const* TEnumTraits<::nebula::cpp2::ErrorCode>::findName(type value) { + using factory = ::nebula::cpp2::_ErrorCode_EnumMapFactory; + static folly::Indestructible const map{ + factory::makeValuesToNamesMap()}; + auto found = map->find(value); + return found == map->end() ? nullptr : found->second; +} + +bool TEnumTraits<::nebula::cpp2::ErrorCode>::findValue(char const* name, type* out) { + using factory = ::nebula::cpp2::_ErrorCode_EnumMapFactory; + static folly::Indestructible const map{ + factory::makeNamesToValuesMap()}; + auto found = map->find(name); + return found == map->end() ? false : (*out = found->second, true); +} + +}} // apache::thrift + +namespace nebula { namespace cpp2 { +FOLLY_PUSH_WARNING +FOLLY_GNU_DISABLE_WARNING("-Wdeprecated-declarations") +const _ErrorCode_EnumMapFactory::ValuesToNamesMapType _ErrorCode_VALUES_TO_NAMES = _ErrorCode_EnumMapFactory::makeValuesToNamesMap(); +const _ErrorCode_EnumMapFactory::NamesToValuesMapType _ErrorCode_NAMES_TO_VALUES = _ErrorCode_EnumMapFactory::makeNamesToValuesMap(); +FOLLY_POP_WARNING + +}} // nebula::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::cpp2::SchemaID>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::cpp2::SchemaID>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace apache { namespace thrift { + +constexpr std::size_t const TEnumTraits<::nebula::cpp2::SchemaID::Type>::size; +folly::Range<::nebula::cpp2::SchemaID::Type const*> const TEnumTraits<::nebula::cpp2::SchemaID::Type>::values = folly::range(TEnumDataStorage<::nebula::cpp2::SchemaID::Type>::values); +folly::Range const TEnumTraits<::nebula::cpp2::SchemaID::Type>::names = folly::range(TEnumDataStorage<::nebula::cpp2::SchemaID::Type>::names); + +char const* TEnumTraits<::nebula::cpp2::SchemaID::Type>::findName(type value) { + using factory = detail::TEnumMapFactory<::nebula::cpp2::SchemaID::Type>; + static folly::Indestructible const map{ + factory::makeValuesToNamesMap()}; + auto found = map->find(value); + return found == map->end() ? nullptr : found->second; +} + +bool TEnumTraits<::nebula::cpp2::SchemaID::Type>::findValue(char const* name, type* out) { + using factory = detail::TEnumMapFactory<::nebula::cpp2::SchemaID::Type>; + static folly::Indestructible const map{ + factory::makeNamesToValuesMap()}; + auto found = map->find(name); + return found == map->end() ? false : (*out = found->second, true); +} +}} // apache::thrift +namespace nebula { namespace cpp2 { + +void SchemaID::__clear() { + // clear all fields + if (type_ == Type::__EMPTY__) { return; } + switch(type_) { + case Type::tag_id: + destruct(value_.tag_id); + break; + case Type::edge_type: + destruct(value_.edge_type); + break; + default: + assert(false); + break; + } + type_ = Type::__EMPTY__; +} + +bool SchemaID::operator==(const SchemaID& rhs) const { + if (type_ != rhs.type_) { return false; } + switch(type_) { + case Type::tag_id: + return value_.tag_id == rhs.value_.tag_id; + case Type::edge_type: + return value_.edge_type == rhs.value_.edge_type; + default: + return true; + } +} + +bool SchemaID::operator<(const SchemaID& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (lhs.type_ != rhs.type_) { + return lhs.type_ < rhs.type_; + } + switch (lhs.type_) { + case Type::tag_id: + return lhs.value_.tag_id < rhs.value_.tag_id; + case Type::edge_type: + return lhs.value_.edge_type < rhs.value_.edge_type; + default: + return false; + } +} + +void swap(SchemaID& a, SchemaID& b) { + SchemaID temp(std::move(a)); + a = std::move(b); + b = std::move(temp); +} + +template void SchemaID::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t SchemaID::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t SchemaID::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t SchemaID::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void SchemaID::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t SchemaID::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t SchemaID::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t SchemaID::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}} // nebula::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::cpp2::Date>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::cpp2::Date>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +Date::Date(apache::thrift::FragileConstructor, int16_t year__arg, int8_t month__arg, int8_t day__arg) : + year(std::move(year__arg)), + month(std::move(month__arg)), + day(std::move(day__arg)) { + __isset.year = true; + __isset.month = true; + __isset.day = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void Date::__clear() { + // clear all fields + year = 0; + month = 0; + day = 0; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool Date::operator==(const Date& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.year == rhs.year)) { + return false; + } + if (!(lhs.month == rhs.month)) { + return false; + } + if (!(lhs.day == rhs.day)) { + return false; + } + return true; +} + +bool Date::operator<(const Date& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.year == rhs.year)) { + return lhs.year < rhs.year; + } + if (!(lhs.month == rhs.month)) { + return lhs.month < rhs.month; + } + if (!(lhs.day == rhs.day)) { + return lhs.day < rhs.day; + } + return false; +} + + +void swap(Date& a, Date& b) { + using ::std::swap; + swap(a.year_ref().value(), b.year_ref().value()); + swap(a.month_ref().value(), b.month_ref().value()); + swap(a.day_ref().value(), b.day_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void Date::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t Date::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t Date::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t Date::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void Date::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t Date::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t Date::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t Date::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}} // nebula::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::cpp2::Time>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::cpp2::Time>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +Time::Time(apache::thrift::FragileConstructor, int8_t hour__arg, int8_t minute__arg, int8_t sec__arg, int32_t microsec__arg) : + hour(std::move(hour__arg)), + minute(std::move(minute__arg)), + sec(std::move(sec__arg)), + microsec(std::move(microsec__arg)) { + __isset.hour = true; + __isset.minute = true; + __isset.sec = true; + __isset.microsec = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void Time::__clear() { + // clear all fields + hour = 0; + minute = 0; + sec = 0; + microsec = 0; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool Time::operator==(const Time& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.hour == rhs.hour)) { + return false; + } + if (!(lhs.minute == rhs.minute)) { + return false; + } + if (!(lhs.sec == rhs.sec)) { + return false; + } + if (!(lhs.microsec == rhs.microsec)) { + return false; + } + return true; +} + +bool Time::operator<(const Time& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.hour == rhs.hour)) { + return lhs.hour < rhs.hour; + } + if (!(lhs.minute == rhs.minute)) { + return lhs.minute < rhs.minute; + } + if (!(lhs.sec == rhs.sec)) { + return lhs.sec < rhs.sec; + } + if (!(lhs.microsec == rhs.microsec)) { + return lhs.microsec < rhs.microsec; + } + return false; +} + + +void swap(Time& a, Time& b) { + using ::std::swap; + swap(a.hour_ref().value(), b.hour_ref().value()); + swap(a.minute_ref().value(), b.minute_ref().value()); + swap(a.sec_ref().value(), b.sec_ref().value()); + swap(a.microsec_ref().value(), b.microsec_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void Time::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t Time::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t Time::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t Time::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void Time::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t Time::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t Time::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t Time::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}} // nebula::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::cpp2::DateTime>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::cpp2::DateTime>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +DateTime::DateTime(apache::thrift::FragileConstructor, int16_t year__arg, int8_t month__arg, int8_t day__arg, int8_t hour__arg, int8_t minute__arg, int8_t sec__arg, int32_t microsec__arg) : + year(std::move(year__arg)), + month(std::move(month__arg)), + day(std::move(day__arg)), + hour(std::move(hour__arg)), + minute(std::move(minute__arg)), + sec(std::move(sec__arg)), + microsec(std::move(microsec__arg)) { + __isset.year = true; + __isset.month = true; + __isset.day = true; + __isset.hour = true; + __isset.minute = true; + __isset.sec = true; + __isset.microsec = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void DateTime::__clear() { + // clear all fields + year = 0; + month = 0; + day = 0; + hour = 0; + minute = 0; + sec = 0; + microsec = 0; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool DateTime::operator==(const DateTime& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.year == rhs.year)) { + return false; + } + if (!(lhs.month == rhs.month)) { + return false; + } + if (!(lhs.day == rhs.day)) { + return false; + } + if (!(lhs.hour == rhs.hour)) { + return false; + } + if (!(lhs.minute == rhs.minute)) { + return false; + } + if (!(lhs.sec == rhs.sec)) { + return false; + } + if (!(lhs.microsec == rhs.microsec)) { + return false; + } + return true; +} + +bool DateTime::operator<(const DateTime& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.year == rhs.year)) { + return lhs.year < rhs.year; + } + if (!(lhs.month == rhs.month)) { + return lhs.month < rhs.month; + } + if (!(lhs.day == rhs.day)) { + return lhs.day < rhs.day; + } + if (!(lhs.hour == rhs.hour)) { + return lhs.hour < rhs.hour; + } + if (!(lhs.minute == rhs.minute)) { + return lhs.minute < rhs.minute; + } + if (!(lhs.sec == rhs.sec)) { + return lhs.sec < rhs.sec; + } + if (!(lhs.microsec == rhs.microsec)) { + return lhs.microsec < rhs.microsec; + } + return false; +} + + +void swap(DateTime& a, DateTime& b) { + using ::std::swap; + swap(a.year_ref().value(), b.year_ref().value()); + swap(a.month_ref().value(), b.month_ref().value()); + swap(a.day_ref().value(), b.day_ref().value()); + swap(a.hour_ref().value(), b.hour_ref().value()); + swap(a.minute_ref().value(), b.minute_ref().value()); + swap(a.sec_ref().value(), b.sec_ref().value()); + swap(a.microsec_ref().value(), b.microsec_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void DateTime::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t DateTime::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t DateTime::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t DateTime::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void DateTime::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t DateTime::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t DateTime::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t DateTime::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}} // nebula::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::cpp2::Value>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::cpp2::Value>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace apache { namespace thrift { + +constexpr std::size_t const TEnumTraits<::nebula::cpp2::Value::Type>::size; +folly::Range<::nebula::cpp2::Value::Type const*> const TEnumTraits<::nebula::cpp2::Value::Type>::values = folly::range(TEnumDataStorage<::nebula::cpp2::Value::Type>::values); +folly::Range const TEnumTraits<::nebula::cpp2::Value::Type>::names = folly::range(TEnumDataStorage<::nebula::cpp2::Value::Type>::names); + +char const* TEnumTraits<::nebula::cpp2::Value::Type>::findName(type value) { + using factory = detail::TEnumMapFactory<::nebula::cpp2::Value::Type>; + static folly::Indestructible const map{ + factory::makeValuesToNamesMap()}; + auto found = map->find(value); + return found == map->end() ? nullptr : found->second; +} + +bool TEnumTraits<::nebula::cpp2::Value::Type>::findValue(char const* name, type* out) { + using factory = detail::TEnumMapFactory<::nebula::cpp2::Value::Type>; + static folly::Indestructible const map{ + factory::makeNamesToValuesMap()}; + auto found = map->find(name); + return found == map->end() ? false : (*out = found->second, true); +} +}} // apache::thrift +namespace nebula { namespace cpp2 { + +void Value::__clear() { + // clear all fields + if (type_ == Type::__EMPTY__) { return; } + switch(type_) { + case Type::nVal: + destruct(value_.nVal); + break; + case Type::bVal: + destruct(value_.bVal); + break; + case Type::iVal: + destruct(value_.iVal); + break; + case Type::fVal: + destruct(value_.fVal); + break; + case Type::sVal: + destruct(value_.sVal); + break; + case Type::dVal: + destruct(value_.dVal); + break; + case Type::tVal: + destruct(value_.tVal); + break; + case Type::dtVal: + destruct(value_.dtVal); + break; + case Type::vVal: + destruct(value_.vVal); + break; + case Type::eVal: + destruct(value_.eVal); + break; + case Type::pVal: + destruct(value_.pVal); + break; + case Type::lVal: + destruct(value_.lVal); + break; + case Type::mVal: + destruct(value_.mVal); + break; + case Type::uVal: + destruct(value_.uVal); + break; + case Type::gVal: + destruct(value_.gVal); + break; + case Type::ggVal: + destruct(value_.ggVal); + break; + default: + assert(false); + break; + } + type_ = Type::__EMPTY__; +} + +bool Value::operator==(const Value& rhs) const { + if (type_ != rhs.type_) { return false; } + switch(type_) { + case Type::nVal: + return value_.nVal == rhs.value_.nVal; + case Type::bVal: + return value_.bVal == rhs.value_.bVal; + case Type::iVal: + return value_.iVal == rhs.value_.iVal; + case Type::fVal: + return value_.fVal == rhs.value_.fVal; + case Type::sVal: + return apache::thrift::StringTraits::isEqual( + value_.sVal, + rhs.value_.sVal); + case Type::dVal: + return value_.dVal == rhs.value_.dVal; + case Type::tVal: + return value_.tVal == rhs.value_.tVal; + case Type::dtVal: + return value_.dtVal == rhs.value_.dtVal; + case Type::vVal: + return *value_.vVal == *rhs.value_.vVal; + case Type::eVal: + return *value_.eVal == *rhs.value_.eVal; + case Type::pVal: + return *value_.pVal == *rhs.value_.pVal; + case Type::lVal: + return *value_.lVal == *rhs.value_.lVal; + case Type::mVal: + return *value_.mVal == *rhs.value_.mVal; + case Type::uVal: + return *value_.uVal == *rhs.value_.uVal; + case Type::gVal: + return *value_.gVal == *rhs.value_.gVal; + case Type::ggVal: + return *value_.ggVal == *rhs.value_.ggVal; + default: + return true; + } +} + +std::unique_ptr& Value::set_vVal(nebula::Vertex const &t) { + __clear(); + type_ = Type::vVal; + ::new (std::addressof(value_.vVal)) std::unique_ptr(new std::unique_ptr::element_type(t)); + return value_.vVal; +} + +std::unique_ptr& Value::set_vVal(nebula::Vertex&& t) { + __clear(); + type_ = Type::vVal; + ::new (std::addressof(value_.vVal)) std::unique_ptr(new std::unique_ptr::element_type(std::move(t))); + return value_.vVal; +} + +std::unique_ptr& Value::set_eVal(nebula::Edge const &t) { + __clear(); + type_ = Type::eVal; + ::new (std::addressof(value_.eVal)) std::unique_ptr(new std::unique_ptr::element_type(t)); + return value_.eVal; +} + +std::unique_ptr& Value::set_eVal(nebula::Edge&& t) { + __clear(); + type_ = Type::eVal; + ::new (std::addressof(value_.eVal)) std::unique_ptr(new std::unique_ptr::element_type(std::move(t))); + return value_.eVal; +} + +std::unique_ptr& Value::set_pVal(nebula::Path const &t) { + __clear(); + type_ = Type::pVal; + ::new (std::addressof(value_.pVal)) std::unique_ptr(new std::unique_ptr::element_type(t)); + return value_.pVal; +} + +std::unique_ptr& Value::set_pVal(nebula::Path&& t) { + __clear(); + type_ = Type::pVal; + ::new (std::addressof(value_.pVal)) std::unique_ptr(new std::unique_ptr::element_type(std::move(t))); + return value_.pVal; +} + +std::unique_ptr& Value::set_lVal(nebula::List const &t) { + __clear(); + type_ = Type::lVal; + ::new (std::addressof(value_.lVal)) std::unique_ptr(new std::unique_ptr::element_type(t)); + return value_.lVal; +} + +std::unique_ptr& Value::set_lVal(nebula::List&& t) { + __clear(); + type_ = Type::lVal; + ::new (std::addressof(value_.lVal)) std::unique_ptr(new std::unique_ptr::element_type(std::move(t))); + return value_.lVal; +} + +std::unique_ptr& Value::set_mVal(nebula::Map const &t) { + __clear(); + type_ = Type::mVal; + ::new (std::addressof(value_.mVal)) std::unique_ptr(new std::unique_ptr::element_type(t)); + return value_.mVal; +} + +std::unique_ptr& Value::set_mVal(nebula::Map&& t) { + __clear(); + type_ = Type::mVal; + ::new (std::addressof(value_.mVal)) std::unique_ptr(new std::unique_ptr::element_type(std::move(t))); + return value_.mVal; +} + +std::unique_ptr& Value::set_uVal(nebula::Set const &t) { + __clear(); + type_ = Type::uVal; + ::new (std::addressof(value_.uVal)) std::unique_ptr(new std::unique_ptr::element_type(t)); + return value_.uVal; +} + +std::unique_ptr& Value::set_uVal(nebula::Set&& t) { + __clear(); + type_ = Type::uVal; + ::new (std::addressof(value_.uVal)) std::unique_ptr(new std::unique_ptr::element_type(std::move(t))); + return value_.uVal; +} + +std::unique_ptr& Value::set_gVal(nebula::DataSet const &t) { + __clear(); + type_ = Type::gVal; + ::new (std::addressof(value_.gVal)) std::unique_ptr(new std::unique_ptr::element_type(t)); + return value_.gVal; +} + +std::unique_ptr& Value::set_gVal(nebula::DataSet&& t) { + __clear(); + type_ = Type::gVal; + ::new (std::addressof(value_.gVal)) std::unique_ptr(new std::unique_ptr::element_type(std::move(t))); + return value_.gVal; +} + +std::unique_ptr& Value::set_ggVal(nebula::Geography const &t) { + __clear(); + type_ = Type::ggVal; + ::new (std::addressof(value_.ggVal)) std::unique_ptr(new std::unique_ptr::element_type(t)); + return value_.ggVal; +} + +std::unique_ptr& Value::set_ggVal(nebula::Geography&& t) { + __clear(); + type_ = Type::ggVal; + ::new (std::addressof(value_.ggVal)) std::unique_ptr(new std::unique_ptr::element_type(std::move(t))); + return value_.ggVal; +} + +void swap(Value& a, Value& b) { + Value temp(std::move(a)); + a = std::move(b); + b = std::move(temp); +} + +template void Value::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t Value::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t Value::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t Value::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void Value::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t Value::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t Value::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t Value::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + Value, + ::apache::thrift::type_class::structure, + nebula::Date>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + Value, + ::apache::thrift::type_class::structure, + nebula::Time>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + Value, + ::apache::thrift::type_class::structure, + nebula::DateTime>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + Value, + ::apache::thrift::type_class::structure, + nebula::Vertex>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + Value, + ::apache::thrift::type_class::structure, + nebula::Edge>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + Value, + ::apache::thrift::type_class::structure, + nebula::Path>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + Value, + ::apache::thrift::type_class::structure, + nebula::List>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + Value, + ::apache::thrift::type_class::structure, + nebula::Map>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + Value, + ::apache::thrift::type_class::structure, + nebula::Set>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + Value, + ::apache::thrift::type_class::structure, + nebula::DataSet>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + Value, + ::apache::thrift::type_class::structure, + nebula::Geography>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + Value, + ::apache::thrift::type_class::structure, + nebula::Date>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + Value, + ::apache::thrift::type_class::structure, + nebula::Time>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + Value, + ::apache::thrift::type_class::structure, + nebula::DateTime>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + Value, + ::apache::thrift::type_class::structure, + nebula::Vertex>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + Value, + ::apache::thrift::type_class::structure, + nebula::Edge>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + Value, + ::apache::thrift::type_class::structure, + nebula::Path>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + Value, + ::apache::thrift::type_class::structure, + nebula::List>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + Value, + ::apache::thrift::type_class::structure, + nebula::Map>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + Value, + ::apache::thrift::type_class::structure, + nebula::Set>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + Value, + ::apache::thrift::type_class::structure, + nebula::DataSet>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + Value, + ::apache::thrift::type_class::structure, + nebula::Geography>, + "inconsistent use of nimble option"); + +}} // nebula::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::cpp2::NList>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::cpp2::NList>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +NList::NList(apache::thrift::FragileConstructor, ::std::vector values__arg) : + values(std::move(values__arg)) { + __isset.values = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void NList::__clear() { + // clear all fields + values.clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool NList::operator==(const NList& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.values == rhs.values)) { + return false; + } + return true; +} + +const ::std::vector& NList::get_values() const& { + return values; +} + +::std::vector NList::get_values() && { + return std::move(values); +} + + +void swap(NList& a, NList& b) { + using ::std::swap; + swap(a.values_ref().value(), b.values_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void NList::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t NList::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t NList::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t NList::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void NList::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t NList::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t NList::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t NList::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + NList, + ::apache::thrift::type_class::list<::apache::thrift::type_class::variant>, + ::std::vector>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + NList, + ::apache::thrift::type_class::list<::apache::thrift::type_class::variant>, + ::std::vector>, + "inconsistent use of nimble option"); + +}} // nebula::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::cpp2::NMap>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::cpp2::NMap>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +NMap::NMap(apache::thrift::FragileConstructor, std::unordered_map<::std::string, nebula::Value> kvs__arg) : + kvs(std::move(kvs__arg)) { + __isset.kvs = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void NMap::__clear() { + // clear all fields + kvs.clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool NMap::operator==(const NMap& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.kvs == rhs.kvs)) { + return false; + } + return true; +} + +const std::unordered_map<::std::string, nebula::Value>& NMap::get_kvs() const& { + return kvs; +} + +std::unordered_map<::std::string, nebula::Value> NMap::get_kvs() && { + return std::move(kvs); +} + + +void swap(NMap& a, NMap& b) { + using ::std::swap; + swap(a.kvs_ref().value(), b.kvs_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void NMap::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t NMap::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t NMap::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t NMap::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void NMap::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t NMap::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t NMap::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t NMap::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + NMap, + ::apache::thrift::type_class::map<::apache::thrift::type_class::binary, ::apache::thrift::type_class::variant>, + std::unordered_map<::std::string, nebula::Value>>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + NMap, + ::apache::thrift::type_class::map<::apache::thrift::type_class::binary, ::apache::thrift::type_class::variant>, + std::unordered_map<::std::string, nebula::Value>>, + "inconsistent use of nimble option"); + +}} // nebula::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::cpp2::NSet>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::cpp2::NSet>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +NSet::NSet(apache::thrift::FragileConstructor, std::unordered_set values__arg) : + values(std::move(values__arg)) { + __isset.values = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void NSet::__clear() { + // clear all fields + values.clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool NSet::operator==(const NSet& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.values == rhs.values)) { + return false; + } + return true; +} + +const std::unordered_set& NSet::get_values() const& { + return values; +} + +std::unordered_set NSet::get_values() && { + return std::move(values); +} + + +void swap(NSet& a, NSet& b) { + using ::std::swap; + swap(a.values_ref().value(), b.values_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void NSet::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t NSet::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t NSet::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t NSet::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void NSet::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t NSet::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t NSet::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t NSet::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + NSet, + ::apache::thrift::type_class::set<::apache::thrift::type_class::variant>, + std::unordered_set>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + NSet, + ::apache::thrift::type_class::set<::apache::thrift::type_class::variant>, + std::unordered_set>, + "inconsistent use of nimble option"); + +}} // nebula::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::cpp2::Row>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::cpp2::Row>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +Row::Row(apache::thrift::FragileConstructor, ::std::vector values__arg) : + values(std::move(values__arg)) { + __isset.values = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void Row::__clear() { + // clear all fields + values.clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool Row::operator==(const Row& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.values == rhs.values)) { + return false; + } + return true; +} + +const ::std::vector& Row::get_values() const& { + return values; +} + +::std::vector Row::get_values() && { + return std::move(values); +} + + +void swap(Row& a, Row& b) { + using ::std::swap; + swap(a.values_ref().value(), b.values_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void Row::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t Row::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t Row::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t Row::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void Row::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t Row::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t Row::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t Row::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + Row, + ::apache::thrift::type_class::list<::apache::thrift::type_class::variant>, + ::std::vector>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + Row, + ::apache::thrift::type_class::list<::apache::thrift::type_class::variant>, + ::std::vector>, + "inconsistent use of nimble option"); + +}} // nebula::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::cpp2::DataSet>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::cpp2::DataSet>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +DataSet::DataSet(apache::thrift::FragileConstructor, ::std::vector<::std::string> column_names__arg, ::std::vector rows__arg) : + column_names(std::move(column_names__arg)), + rows(std::move(rows__arg)) { + __isset.column_names = true; + __isset.rows = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void DataSet::__clear() { + // clear all fields + column_names.clear(); + rows.clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool DataSet::operator==(const DataSet& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.column_names == rhs.column_names)) { + return false; + } + if (!(lhs.rows == rhs.rows)) { + return false; + } + return true; +} + +const ::std::vector<::std::string>& DataSet::get_column_names() const& { + return column_names; +} + +::std::vector<::std::string> DataSet::get_column_names() && { + return std::move(column_names); +} + +const ::std::vector& DataSet::get_rows() const& { + return rows; +} + +::std::vector DataSet::get_rows() && { + return std::move(rows); +} + + +void swap(DataSet& a, DataSet& b) { + using ::std::swap; + swap(a.column_names_ref().value(), b.column_names_ref().value()); + swap(a.rows_ref().value(), b.rows_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void DataSet::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t DataSet::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t DataSet::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t DataSet::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void DataSet::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t DataSet::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t DataSet::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t DataSet::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + DataSet, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + DataSet, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector>, + "inconsistent use of nimble option"); + +}} // nebula::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::cpp2::Geography>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::cpp2::Geography>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +Geography::Geography(apache::thrift::FragileConstructor, ::std::string wkb__arg) : + wkb(std::move(wkb__arg)) { + __isset.wkb = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void Geography::__clear() { + // clear all fields + wkb = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool Geography::operator==(const Geography& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.wkb == rhs.wkb)) { + return false; + } + return true; +} + +bool Geography::operator<(const Geography& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.wkb == rhs.wkb)) { + return lhs.wkb < rhs.wkb; + } + return false; +} + + +void swap(Geography& a, Geography& b) { + using ::std::swap; + swap(a.wkb_ref().value(), b.wkb_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void Geography::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t Geography::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t Geography::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t Geography::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void Geography::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t Geography::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t Geography::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t Geography::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}} // nebula::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::cpp2::Tag>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::cpp2::Tag>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +Tag::Tag(apache::thrift::FragileConstructor, ::std::string name__arg, std::unordered_map<::std::string, nebula::Value> props__arg) : + name(std::move(name__arg)), + props(std::move(props__arg)) { + __isset.name = true; + __isset.props = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void Tag::__clear() { + // clear all fields + name = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); + props.clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool Tag::operator==(const Tag& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!apache::thrift::StringTraits::isEqual(lhs.name, rhs.name)) { + return false; + } + if (!(lhs.props == rhs.props)) { + return false; + } + return true; +} + +const std::unordered_map<::std::string, nebula::Value>& Tag::get_props() const& { + return props; +} + +std::unordered_map<::std::string, nebula::Value> Tag::get_props() && { + return std::move(props); +} + + +void swap(Tag& a, Tag& b) { + using ::std::swap; + swap(a.name_ref().value(), b.name_ref().value()); + swap(a.props_ref().value(), b.props_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void Tag::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t Tag::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t Tag::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t Tag::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void Tag::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t Tag::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t Tag::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t Tag::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + Tag, + ::apache::thrift::type_class::map<::apache::thrift::type_class::binary, ::apache::thrift::type_class::variant>, + std::unordered_map<::std::string, nebula::Value>>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + Tag, + ::apache::thrift::type_class::map<::apache::thrift::type_class::binary, ::apache::thrift::type_class::variant>, + std::unordered_map<::std::string, nebula::Value>>, + "inconsistent use of nimble option"); + +}} // nebula::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::cpp2::Vertex>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::cpp2::Vertex>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +Vertex::Vertex(apache::thrift::FragileConstructor, nebula::Value vid__arg, ::std::vector tags__arg) : + vid(std::move(vid__arg)), + tags(std::move(tags__arg)) { + __isset.vid = true; + __isset.tags = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void Vertex::__clear() { + // clear all fields + vid.__clear(); + tags.clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool Vertex::operator==(const Vertex& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.vid == rhs.vid)) { + return false; + } + if (!(lhs.tags == rhs.tags)) { + return false; + } + return true; +} + +const nebula::Value& Vertex::get_vid() const& { + return vid; +} + +nebula::Value Vertex::get_vid() && { + return std::move(vid); +} + +const ::std::vector& Vertex::get_tags() const& { + return tags; +} + +::std::vector Vertex::get_tags() && { + return std::move(tags); +} + + +void swap(Vertex& a, Vertex& b) { + using ::std::swap; + swap(a.vid_ref().value(), b.vid_ref().value()); + swap(a.tags_ref().value(), b.tags_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void Vertex::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t Vertex::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t Vertex::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t Vertex::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void Vertex::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t Vertex::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t Vertex::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t Vertex::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + Vertex, + ::apache::thrift::type_class::variant, + nebula::Value>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + Vertex, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + Vertex, + ::apache::thrift::type_class::variant, + nebula::Value>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + Vertex, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector>, + "inconsistent use of nimble option"); + +}} // nebula::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::cpp2::Edge>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::cpp2::Edge>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +Edge::Edge() : + type(0), + ranking(0) {} +THRIFT_IGNORE_ISSET_USE_WARNING_END + + +Edge::~Edge() {} + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +Edge::Edge(apache::thrift::FragileConstructor, nebula::Value src__arg, nebula::Value dst__arg, ::nebula::cpp2::EdgeType type__arg, ::std::string name__arg, ::nebula::cpp2::EdgeRanking ranking__arg, std::unordered_map<::std::string, nebula::Value> props__arg) : + src(std::move(src__arg)), + dst(std::move(dst__arg)), + type(std::move(type__arg)), + name(std::move(name__arg)), + ranking(std::move(ranking__arg)), + props(std::move(props__arg)) { + __isset.src = true; + __isset.dst = true; + __isset.type = true; + __isset.name = true; + __isset.ranking = true; + __isset.props = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void Edge::__clear() { + // clear all fields + src.__clear(); + dst.__clear(); + type = 0; + name = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); + ranking = 0; + props.clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool Edge::operator==(const Edge& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.src == rhs.src)) { + return false; + } + if (!(lhs.dst == rhs.dst)) { + return false; + } + if (!(lhs.type == rhs.type)) { + return false; + } + if (!apache::thrift::StringTraits::isEqual(lhs.name, rhs.name)) { + return false; + } + if (!(lhs.ranking == rhs.ranking)) { + return false; + } + if (!(lhs.props == rhs.props)) { + return false; + } + return true; +} + +const nebula::Value& Edge::get_src() const& { + return src; +} + +nebula::Value Edge::get_src() && { + return std::move(src); +} + +const nebula::Value& Edge::get_dst() const& { + return dst; +} + +nebula::Value Edge::get_dst() && { + return std::move(dst); +} + +const std::unordered_map<::std::string, nebula::Value>& Edge::get_props() const& { + return props; +} + +std::unordered_map<::std::string, nebula::Value> Edge::get_props() && { + return std::move(props); +} + + +void swap(Edge& a, Edge& b) { + using ::std::swap; + swap(a.src_ref().value(), b.src_ref().value()); + swap(a.dst_ref().value(), b.dst_ref().value()); + swap(a.type_ref().value(), b.type_ref().value()); + swap(a.name_ref().value(), b.name_ref().value()); + swap(a.ranking_ref().value(), b.ranking_ref().value()); + swap(a.props_ref().value(), b.props_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void Edge::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t Edge::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t Edge::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t Edge::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void Edge::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t Edge::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t Edge::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t Edge::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + Edge, + ::apache::thrift::type_class::variant, + nebula::Value>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + Edge, + ::apache::thrift::type_class::variant, + nebula::Value>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + Edge, + ::apache::thrift::type_class::map<::apache::thrift::type_class::binary, ::apache::thrift::type_class::variant>, + std::unordered_map<::std::string, nebula::Value>>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + Edge, + ::apache::thrift::type_class::variant, + nebula::Value>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + Edge, + ::apache::thrift::type_class::variant, + nebula::Value>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + Edge, + ::apache::thrift::type_class::map<::apache::thrift::type_class::binary, ::apache::thrift::type_class::variant>, + std::unordered_map<::std::string, nebula::Value>>, + "inconsistent use of nimble option"); + +}} // nebula::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::cpp2::Step>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::cpp2::Step>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +Step::Step() : + type(0), + ranking(0) {} +THRIFT_IGNORE_ISSET_USE_WARNING_END + + +Step::~Step() {} + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +Step::Step(apache::thrift::FragileConstructor, nebula::Vertex dst__arg, ::nebula::cpp2::EdgeType type__arg, ::std::string name__arg, ::nebula::cpp2::EdgeRanking ranking__arg, std::unordered_map<::std::string, nebula::Value> props__arg) : + dst(std::move(dst__arg)), + type(std::move(type__arg)), + name(std::move(name__arg)), + ranking(std::move(ranking__arg)), + props(std::move(props__arg)) { + __isset.dst = true; + __isset.type = true; + __isset.name = true; + __isset.ranking = true; + __isset.props = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void Step::__clear() { + // clear all fields + dst.__clear(); + type = 0; + name = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); + ranking = 0; + props.clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool Step::operator==(const Step& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.dst == rhs.dst)) { + return false; + } + if (!(lhs.type == rhs.type)) { + return false; + } + if (!apache::thrift::StringTraits::isEqual(lhs.name, rhs.name)) { + return false; + } + if (!(lhs.ranking == rhs.ranking)) { + return false; + } + if (!(lhs.props == rhs.props)) { + return false; + } + return true; +} + +const nebula::Vertex& Step::get_dst() const& { + return dst; +} + +nebula::Vertex Step::get_dst() && { + return std::move(dst); +} + +const std::unordered_map<::std::string, nebula::Value>& Step::get_props() const& { + return props; +} + +std::unordered_map<::std::string, nebula::Value> Step::get_props() && { + return std::move(props); +} + + +void swap(Step& a, Step& b) { + using ::std::swap; + swap(a.dst_ref().value(), b.dst_ref().value()); + swap(a.type_ref().value(), b.type_ref().value()); + swap(a.name_ref().value(), b.name_ref().value()); + swap(a.ranking_ref().value(), b.ranking_ref().value()); + swap(a.props_ref().value(), b.props_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void Step::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t Step::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t Step::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t Step::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void Step::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t Step::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t Step::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t Step::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + Step, + ::apache::thrift::type_class::structure, + nebula::Vertex>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + Step, + ::apache::thrift::type_class::map<::apache::thrift::type_class::binary, ::apache::thrift::type_class::variant>, + std::unordered_map<::std::string, nebula::Value>>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + Step, + ::apache::thrift::type_class::structure, + nebula::Vertex>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + Step, + ::apache::thrift::type_class::map<::apache::thrift::type_class::binary, ::apache::thrift::type_class::variant>, + std::unordered_map<::std::string, nebula::Value>>, + "inconsistent use of nimble option"); + +}} // nebula::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::cpp2::Path>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::cpp2::Path>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +Path::Path(apache::thrift::FragileConstructor, nebula::Vertex src__arg, ::std::vector steps__arg) : + src(std::move(src__arg)), + steps(std::move(steps__arg)) { + __isset.src = true; + __isset.steps = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void Path::__clear() { + // clear all fields + src.__clear(); + steps.clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool Path::operator==(const Path& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.src == rhs.src)) { + return false; + } + if (!(lhs.steps == rhs.steps)) { + return false; + } + return true; +} + +const nebula::Vertex& Path::get_src() const& { + return src; +} + +nebula::Vertex Path::get_src() && { + return std::move(src); +} + +const ::std::vector& Path::get_steps() const& { + return steps; +} + +::std::vector Path::get_steps() && { + return std::move(steps); +} + + +void swap(Path& a, Path& b) { + using ::std::swap; + swap(a.src_ref().value(), b.src_ref().value()); + swap(a.steps_ref().value(), b.steps_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void Path::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t Path::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t Path::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t Path::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void Path::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t Path::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t Path::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t Path::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + Path, + ::apache::thrift::type_class::structure, + nebula::Vertex>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + Path, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + Path, + ::apache::thrift::type_class::structure, + nebula::Vertex>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + Path, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector>, + "inconsistent use of nimble option"); + +}} // nebula::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::cpp2::HostAddr>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::cpp2::HostAddr>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +HostAddr::HostAddr(apache::thrift::FragileConstructor, ::std::string host__arg, ::nebula::cpp2::Port port__arg) : + host(std::move(host__arg)), + port(std::move(port__arg)) { + __isset.host = true; + __isset.port = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void HostAddr::__clear() { + // clear all fields + host = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); + port = 0; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool HostAddr::operator==(const HostAddr& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.host == rhs.host)) { + return false; + } + if (!(lhs.port == rhs.port)) { + return false; + } + return true; +} + +bool HostAddr::operator<(const HostAddr& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.host == rhs.host)) { + return lhs.host < rhs.host; + } + if (!(lhs.port == rhs.port)) { + return lhs.port < rhs.port; + } + return false; +} + + +void swap(HostAddr& a, HostAddr& b) { + using ::std::swap; + swap(a.host_ref().value(), b.host_ref().value()); + swap(a.port_ref().value(), b.port_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void HostAddr::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t HostAddr::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t HostAddr::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t HostAddr::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void HostAddr::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t HostAddr::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t HostAddr::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t HostAddr::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}} // nebula::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::cpp2::KeyValue>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::cpp2::KeyValue>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +KeyValue::KeyValue(apache::thrift::FragileConstructor, ::std::string key__arg, ::std::string value__arg) : + key(std::move(key__arg)), + value(std::move(value__arg)) { + __isset.key = true; + __isset.value = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void KeyValue::__clear() { + // clear all fields + key = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); + value = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool KeyValue::operator==(const KeyValue& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!apache::thrift::StringTraits::isEqual(lhs.key, rhs.key)) { + return false; + } + if (!apache::thrift::StringTraits::isEqual(lhs.value, rhs.value)) { + return false; + } + return true; +} + +bool KeyValue::operator<(const KeyValue& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!apache::thrift::StringTraits::isEqual(lhs.key, rhs.key)) { + return apache::thrift::StringTraits::isLess(lhs.key, rhs.key); + } + if (!apache::thrift::StringTraits::isEqual(lhs.value, rhs.value)) { + return apache::thrift::StringTraits::isLess(lhs.value, rhs.value); + } + return false; +} + + +void swap(KeyValue& a, KeyValue& b) { + using ::std::swap; + swap(a.key_ref().value(), b.key_ref().value()); + swap(a.value_ref().value(), b.value_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void KeyValue::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t KeyValue::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t KeyValue::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t KeyValue::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void KeyValue::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t KeyValue::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t KeyValue::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t KeyValue::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}} // nebula::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::cpp2::LogInfo>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::cpp2::LogInfo>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +LogInfo::LogInfo(apache::thrift::FragileConstructor, ::nebula::cpp2::LogID log_id__arg, ::nebula::cpp2::TermID term_id__arg) : + log_id(std::move(log_id__arg)), + term_id(std::move(term_id__arg)) { + __isset.log_id = true; + __isset.term_id = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void LogInfo::__clear() { + // clear all fields + log_id = 0; + term_id = 0; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool LogInfo::operator==(const LogInfo& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.log_id == rhs.log_id)) { + return false; + } + if (!(lhs.term_id == rhs.term_id)) { + return false; + } + return true; +} + +bool LogInfo::operator<(const LogInfo& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.log_id == rhs.log_id)) { + return lhs.log_id < rhs.log_id; + } + if (!(lhs.term_id == rhs.term_id)) { + return lhs.term_id < rhs.term_id; + } + return false; +} + + +void swap(LogInfo& a, LogInfo& b) { + using ::std::swap; + swap(a.log_id_ref().value(), b.log_id_ref().value()); + swap(a.term_id_ref().value(), b.term_id_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void LogInfo::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t LogInfo::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t LogInfo::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t LogInfo::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void LogInfo::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t LogInfo::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t LogInfo::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t LogInfo::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}} // nebula::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::cpp2::DirInfo>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::cpp2::DirInfo>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +DirInfo::DirInfo(apache::thrift::FragileConstructor, ::std::string root__arg, ::std::vector<::std::string> data__arg) : + root(std::move(root__arg)), + data(std::move(data__arg)) { + __isset.root = true; + __isset.data = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void DirInfo::__clear() { + // clear all fields + root = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); + data.clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool DirInfo::operator==(const DirInfo& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!apache::thrift::StringTraits::isEqual(lhs.root, rhs.root)) { + return false; + } + if (!(lhs.data == rhs.data)) { + return false; + } + return true; +} + +bool DirInfo::operator<(const DirInfo& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!apache::thrift::StringTraits::isEqual(lhs.root, rhs.root)) { + return apache::thrift::StringTraits::isLess(lhs.root, rhs.root); + } + if (!(lhs.data == rhs.data)) { + return lhs.data < rhs.data; + } + return false; +} + +const ::std::vector<::std::string>& DirInfo::get_data() const& { + return data; +} + +::std::vector<::std::string> DirInfo::get_data() && { + return std::move(data); +} + + +void swap(DirInfo& a, DirInfo& b) { + using ::std::swap; + swap(a.root_ref().value(), b.root_ref().value()); + swap(a.data_ref().value(), b.data_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void DirInfo::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t DirInfo::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t DirInfo::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t DirInfo::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void DirInfo::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t DirInfo::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t DirInfo::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t DirInfo::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}} // nebula::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::cpp2::NodeInfo>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::cpp2::NodeInfo>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +NodeInfo::NodeInfo(apache::thrift::FragileConstructor, nebula::HostAddr host__arg, ::nebula::cpp2::DirInfo dir__arg) : + host(std::move(host__arg)), + dir(std::move(dir__arg)) { + __isset.host = true; + __isset.dir = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void NodeInfo::__clear() { + // clear all fields + host.__clear(); + dir.__clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool NodeInfo::operator==(const NodeInfo& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.host == rhs.host)) { + return false; + } + if (!(lhs.dir == rhs.dir)) { + return false; + } + return true; +} + +bool NodeInfo::operator<(const NodeInfo& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.host == rhs.host)) { + return lhs.host < rhs.host; + } + if (!(lhs.dir == rhs.dir)) { + return lhs.dir < rhs.dir; + } + return false; +} + +const nebula::HostAddr& NodeInfo::get_host() const& { + return host; +} + +nebula::HostAddr NodeInfo::get_host() && { + return std::move(host); +} + +const ::nebula::cpp2::DirInfo& NodeInfo::get_dir() const& { + return dir; +} + + ::nebula::cpp2::DirInfo NodeInfo::get_dir() && { + return std::move(dir); +} + + +void swap(NodeInfo& a, NodeInfo& b) { + using ::std::swap; + swap(a.host_ref().value(), b.host_ref().value()); + swap(a.dir_ref().value(), b.dir_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void NodeInfo::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t NodeInfo::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t NodeInfo::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t NodeInfo::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void NodeInfo::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t NodeInfo::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t NodeInfo::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t NodeInfo::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + NodeInfo, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + NodeInfo, + ::apache::thrift::type_class::structure, + ::nebula::cpp2::DirInfo>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + NodeInfo, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + NodeInfo, + ::apache::thrift::type_class::structure, + ::nebula::cpp2::DirInfo>, + "inconsistent use of nimble option"); + +}} // nebula::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::cpp2::PartitionBackupInfo>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::cpp2::PartitionBackupInfo>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +PartitionBackupInfo::PartitionBackupInfo(apache::thrift::FragileConstructor, std::unordered_map< ::nebula::cpp2::PartitionID, ::nebula::cpp2::LogInfo> info__arg) : + info(std::move(info__arg)) { + __isset.info = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void PartitionBackupInfo::__clear() { + // clear all fields + info.clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool PartitionBackupInfo::operator==(const PartitionBackupInfo& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.info == rhs.info)) { + return false; + } + return true; +} + +const std::unordered_map< ::nebula::cpp2::PartitionID, ::nebula::cpp2::LogInfo>& PartitionBackupInfo::get_info() const& { + return info; +} + +std::unordered_map< ::nebula::cpp2::PartitionID, ::nebula::cpp2::LogInfo> PartitionBackupInfo::get_info() && { + return std::move(info); +} + + +void swap(PartitionBackupInfo& a, PartitionBackupInfo& b) { + using ::std::swap; + swap(a.info_ref().value(), b.info_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void PartitionBackupInfo::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t PartitionBackupInfo::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t PartitionBackupInfo::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t PartitionBackupInfo::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void PartitionBackupInfo::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t PartitionBackupInfo::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t PartitionBackupInfo::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t PartitionBackupInfo::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + PartitionBackupInfo, + ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::structure>, + std::unordered_map< ::nebula::cpp2::PartitionID, ::nebula::cpp2::LogInfo>>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + PartitionBackupInfo, + ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::structure>, + std::unordered_map< ::nebula::cpp2::PartitionID, ::nebula::cpp2::LogInfo>>, + "inconsistent use of nimble option"); + +}} // nebula::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::cpp2::CheckpointInfo>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::cpp2::CheckpointInfo>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +CheckpointInfo::CheckpointInfo(apache::thrift::FragileConstructor, ::nebula::cpp2::PartitionBackupInfo partition_info__arg, ::std::string path__arg) : + partition_info(std::move(partition_info__arg)), + path(std::move(path__arg)) { + __isset.partition_info = true; + __isset.path = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void CheckpointInfo::__clear() { + // clear all fields + partition_info.__clear(); + path = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool CheckpointInfo::operator==(const CheckpointInfo& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.partition_info == rhs.partition_info)) { + return false; + } + if (!apache::thrift::StringTraits::isEqual(lhs.path, rhs.path)) { + return false; + } + return true; +} + +const ::nebula::cpp2::PartitionBackupInfo& CheckpointInfo::get_partition_info() const& { + return partition_info; +} + + ::nebula::cpp2::PartitionBackupInfo CheckpointInfo::get_partition_info() && { + return std::move(partition_info); +} + + +void swap(CheckpointInfo& a, CheckpointInfo& b) { + using ::std::swap; + swap(a.partition_info_ref().value(), b.partition_info_ref().value()); + swap(a.path_ref().value(), b.path_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void CheckpointInfo::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t CheckpointInfo::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t CheckpointInfo::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t CheckpointInfo::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void CheckpointInfo::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t CheckpointInfo::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t CheckpointInfo::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t CheckpointInfo::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + CheckpointInfo, + ::apache::thrift::type_class::structure, + ::nebula::cpp2::PartitionBackupInfo>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + CheckpointInfo, + ::apache::thrift::type_class::structure, + ::nebula::cpp2::PartitionBackupInfo>, + "inconsistent use of nimble option"); + +}} // nebula::cpp2 diff --git a/src/interface/gen-cpp2/common_types.h b/src/interface/gen-cpp2/common_types.h new file mode 100644 index 00000000..fc2eab64 --- /dev/null +++ b/src/interface/gen-cpp2/common_types.h @@ -0,0 +1,5849 @@ +/** + * Autogenerated by Thrift for common.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#pragma once + +#include + + +#include "common/thrift/ThriftTypes.h" +#include "common/datatypes/DateOps-inl.h" +#include "common/datatypes/VertexOps-inl.h" +#include "common/datatypes/EdgeOps-inl.h" +#include "common/datatypes/PathOps-inl.h" +#include "common/datatypes/ValueOps-inl.h" +#include "common/datatypes/MapOps-inl.h" +#include "common/datatypes/ListOps-inl.h" +#include "common/datatypes/SetOps-inl.h" +#include "common/datatypes/DataSetOps-inl.h" +#include "common/datatypes/KeyValueOps-inl.h" +#include "common/datatypes/HostAddrOps-inl.h" +#include "common/datatypes/GeographyOps-inl.h" + +namespace apache { +namespace thrift { +namespace tag { +struct tag_id; +struct edge_type; +struct year; +struct month; +struct day; +struct hour; +struct minute; +struct sec; +struct microsec; +struct year; +struct month; +struct day; +struct hour; +struct minute; +struct sec; +struct microsec; +struct nVal; +struct bVal; +struct iVal; +struct fVal; +struct sVal; +struct dVal; +struct tVal; +struct dtVal; +struct vVal; +struct eVal; +struct pVal; +struct lVal; +struct mVal; +struct uVal; +struct gVal; +struct ggVal; +struct values; +struct kvs; +struct values; +struct values; +struct column_names; +struct rows; +struct wkb; +struct name; +struct props; +struct vid; +struct tags; +struct src; +struct dst; +struct type; +struct name; +struct ranking; +struct props; +struct dst; +struct type; +struct name; +struct ranking; +struct props; +struct src; +struct steps; +struct host; +struct port; +struct key; +struct value; +struct log_id; +struct term_id; +struct root; +struct data; +struct host; +struct dir; +struct info; +struct partition_info; +struct path; +} // namespace tag +namespace detail { +#ifndef APACHE_THRIFT_ACCESSOR_tag_id +#define APACHE_THRIFT_ACCESSOR_tag_id +APACHE_THRIFT_DEFINE_ACCESSOR(tag_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_edge_type +#define APACHE_THRIFT_ACCESSOR_edge_type +APACHE_THRIFT_DEFINE_ACCESSOR(edge_type); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_year +#define APACHE_THRIFT_ACCESSOR_year +APACHE_THRIFT_DEFINE_ACCESSOR(year); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_month +#define APACHE_THRIFT_ACCESSOR_month +APACHE_THRIFT_DEFINE_ACCESSOR(month); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_day +#define APACHE_THRIFT_ACCESSOR_day +APACHE_THRIFT_DEFINE_ACCESSOR(day); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_hour +#define APACHE_THRIFT_ACCESSOR_hour +APACHE_THRIFT_DEFINE_ACCESSOR(hour); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_minute +#define APACHE_THRIFT_ACCESSOR_minute +APACHE_THRIFT_DEFINE_ACCESSOR(minute); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_sec +#define APACHE_THRIFT_ACCESSOR_sec +APACHE_THRIFT_DEFINE_ACCESSOR(sec); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_microsec +#define APACHE_THRIFT_ACCESSOR_microsec +APACHE_THRIFT_DEFINE_ACCESSOR(microsec); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_year +#define APACHE_THRIFT_ACCESSOR_year +APACHE_THRIFT_DEFINE_ACCESSOR(year); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_month +#define APACHE_THRIFT_ACCESSOR_month +APACHE_THRIFT_DEFINE_ACCESSOR(month); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_day +#define APACHE_THRIFT_ACCESSOR_day +APACHE_THRIFT_DEFINE_ACCESSOR(day); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_hour +#define APACHE_THRIFT_ACCESSOR_hour +APACHE_THRIFT_DEFINE_ACCESSOR(hour); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_minute +#define APACHE_THRIFT_ACCESSOR_minute +APACHE_THRIFT_DEFINE_ACCESSOR(minute); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_sec +#define APACHE_THRIFT_ACCESSOR_sec +APACHE_THRIFT_DEFINE_ACCESSOR(sec); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_microsec +#define APACHE_THRIFT_ACCESSOR_microsec +APACHE_THRIFT_DEFINE_ACCESSOR(microsec); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_nVal +#define APACHE_THRIFT_ACCESSOR_nVal +APACHE_THRIFT_DEFINE_ACCESSOR(nVal); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_bVal +#define APACHE_THRIFT_ACCESSOR_bVal +APACHE_THRIFT_DEFINE_ACCESSOR(bVal); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_iVal +#define APACHE_THRIFT_ACCESSOR_iVal +APACHE_THRIFT_DEFINE_ACCESSOR(iVal); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_fVal +#define APACHE_THRIFT_ACCESSOR_fVal +APACHE_THRIFT_DEFINE_ACCESSOR(fVal); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_sVal +#define APACHE_THRIFT_ACCESSOR_sVal +APACHE_THRIFT_DEFINE_ACCESSOR(sVal); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_dVal +#define APACHE_THRIFT_ACCESSOR_dVal +APACHE_THRIFT_DEFINE_ACCESSOR(dVal); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_tVal +#define APACHE_THRIFT_ACCESSOR_tVal +APACHE_THRIFT_DEFINE_ACCESSOR(tVal); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_dtVal +#define APACHE_THRIFT_ACCESSOR_dtVal +APACHE_THRIFT_DEFINE_ACCESSOR(dtVal); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_vVal +#define APACHE_THRIFT_ACCESSOR_vVal +APACHE_THRIFT_DEFINE_ACCESSOR(vVal); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_eVal +#define APACHE_THRIFT_ACCESSOR_eVal +APACHE_THRIFT_DEFINE_ACCESSOR(eVal); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_pVal +#define APACHE_THRIFT_ACCESSOR_pVal +APACHE_THRIFT_DEFINE_ACCESSOR(pVal); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_lVal +#define APACHE_THRIFT_ACCESSOR_lVal +APACHE_THRIFT_DEFINE_ACCESSOR(lVal); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_mVal +#define APACHE_THRIFT_ACCESSOR_mVal +APACHE_THRIFT_DEFINE_ACCESSOR(mVal); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_uVal +#define APACHE_THRIFT_ACCESSOR_uVal +APACHE_THRIFT_DEFINE_ACCESSOR(uVal); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_gVal +#define APACHE_THRIFT_ACCESSOR_gVal +APACHE_THRIFT_DEFINE_ACCESSOR(gVal); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_ggVal +#define APACHE_THRIFT_ACCESSOR_ggVal +APACHE_THRIFT_DEFINE_ACCESSOR(ggVal); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_values +#define APACHE_THRIFT_ACCESSOR_values +APACHE_THRIFT_DEFINE_ACCESSOR(values); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_kvs +#define APACHE_THRIFT_ACCESSOR_kvs +APACHE_THRIFT_DEFINE_ACCESSOR(kvs); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_values +#define APACHE_THRIFT_ACCESSOR_values +APACHE_THRIFT_DEFINE_ACCESSOR(values); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_values +#define APACHE_THRIFT_ACCESSOR_values +APACHE_THRIFT_DEFINE_ACCESSOR(values); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_column_names +#define APACHE_THRIFT_ACCESSOR_column_names +APACHE_THRIFT_DEFINE_ACCESSOR(column_names); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_rows +#define APACHE_THRIFT_ACCESSOR_rows +APACHE_THRIFT_DEFINE_ACCESSOR(rows); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_wkb +#define APACHE_THRIFT_ACCESSOR_wkb +APACHE_THRIFT_DEFINE_ACCESSOR(wkb); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_name +#define APACHE_THRIFT_ACCESSOR_name +APACHE_THRIFT_DEFINE_ACCESSOR(name); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_props +#define APACHE_THRIFT_ACCESSOR_props +APACHE_THRIFT_DEFINE_ACCESSOR(props); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_vid +#define APACHE_THRIFT_ACCESSOR_vid +APACHE_THRIFT_DEFINE_ACCESSOR(vid); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_tags +#define APACHE_THRIFT_ACCESSOR_tags +APACHE_THRIFT_DEFINE_ACCESSOR(tags); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_src +#define APACHE_THRIFT_ACCESSOR_src +APACHE_THRIFT_DEFINE_ACCESSOR(src); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_dst +#define APACHE_THRIFT_ACCESSOR_dst +APACHE_THRIFT_DEFINE_ACCESSOR(dst); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_type +#define APACHE_THRIFT_ACCESSOR_type +APACHE_THRIFT_DEFINE_ACCESSOR(type); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_name +#define APACHE_THRIFT_ACCESSOR_name +APACHE_THRIFT_DEFINE_ACCESSOR(name); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_ranking +#define APACHE_THRIFT_ACCESSOR_ranking +APACHE_THRIFT_DEFINE_ACCESSOR(ranking); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_props +#define APACHE_THRIFT_ACCESSOR_props +APACHE_THRIFT_DEFINE_ACCESSOR(props); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_dst +#define APACHE_THRIFT_ACCESSOR_dst +APACHE_THRIFT_DEFINE_ACCESSOR(dst); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_type +#define APACHE_THRIFT_ACCESSOR_type +APACHE_THRIFT_DEFINE_ACCESSOR(type); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_name +#define APACHE_THRIFT_ACCESSOR_name +APACHE_THRIFT_DEFINE_ACCESSOR(name); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_ranking +#define APACHE_THRIFT_ACCESSOR_ranking +APACHE_THRIFT_DEFINE_ACCESSOR(ranking); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_props +#define APACHE_THRIFT_ACCESSOR_props +APACHE_THRIFT_DEFINE_ACCESSOR(props); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_src +#define APACHE_THRIFT_ACCESSOR_src +APACHE_THRIFT_DEFINE_ACCESSOR(src); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_steps +#define APACHE_THRIFT_ACCESSOR_steps +APACHE_THRIFT_DEFINE_ACCESSOR(steps); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_host +#define APACHE_THRIFT_ACCESSOR_host +APACHE_THRIFT_DEFINE_ACCESSOR(host); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_port +#define APACHE_THRIFT_ACCESSOR_port +APACHE_THRIFT_DEFINE_ACCESSOR(port); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_key +#define APACHE_THRIFT_ACCESSOR_key +APACHE_THRIFT_DEFINE_ACCESSOR(key); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_value +#define APACHE_THRIFT_ACCESSOR_value +APACHE_THRIFT_DEFINE_ACCESSOR(value); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_log_id +#define APACHE_THRIFT_ACCESSOR_log_id +APACHE_THRIFT_DEFINE_ACCESSOR(log_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_term_id +#define APACHE_THRIFT_ACCESSOR_term_id +APACHE_THRIFT_DEFINE_ACCESSOR(term_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_root +#define APACHE_THRIFT_ACCESSOR_root +APACHE_THRIFT_DEFINE_ACCESSOR(root); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_data +#define APACHE_THRIFT_ACCESSOR_data +APACHE_THRIFT_DEFINE_ACCESSOR(data); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_host +#define APACHE_THRIFT_ACCESSOR_host +APACHE_THRIFT_DEFINE_ACCESSOR(host); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_dir +#define APACHE_THRIFT_ACCESSOR_dir +APACHE_THRIFT_DEFINE_ACCESSOR(dir); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_info +#define APACHE_THRIFT_ACCESSOR_info +APACHE_THRIFT_DEFINE_ACCESSOR(info); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_partition_info +#define APACHE_THRIFT_ACCESSOR_partition_info +APACHE_THRIFT_DEFINE_ACCESSOR(partition_info); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_path +#define APACHE_THRIFT_ACCESSOR_path +APACHE_THRIFT_DEFINE_ACCESSOR(path); +#endif +} // namespace detail +} // namespace thrift +} // namespace apache + +// BEGIN declare_enums +namespace nebula { namespace cpp2 { + +enum class NullType { + __NULL__ = 0, + NaN = 1, + BAD_DATA = 2, + BAD_TYPE = 3, + ERR_OVERFLOW = 4, + UNKNOWN_PROP = 5, + DIV_BY_ZERO = 6, + OUT_OF_RANGE = 7, +}; + + + + +enum class ErrorCode { + SUCCEEDED = 0, + E_DISCONNECTED = -1, + E_FAIL_TO_CONNECT = -2, + E_RPC_FAILURE = -3, + E_LEADER_CHANGED = -4, + E_SPACE_NOT_FOUND = -5, + E_TAG_NOT_FOUND = -6, + E_EDGE_NOT_FOUND = -7, + E_INDEX_NOT_FOUND = -8, + E_EDGE_PROP_NOT_FOUND = -9, + E_TAG_PROP_NOT_FOUND = -10, + E_ROLE_NOT_FOUND = -11, + E_CONFIG_NOT_FOUND = -12, + E_GROUP_NOT_FOUND = -13, + E_ZONE_NOT_FOUND = -14, + E_LISTENER_NOT_FOUND = -15, + E_PART_NOT_FOUND = -16, + E_KEY_NOT_FOUND = -17, + E_USER_NOT_FOUND = -18, + E_STATS_NOT_FOUND = -19, + E_BACKUP_FAILED = -24, + E_BACKUP_EMPTY_TABLE = -25, + E_BACKUP_TABLE_FAILED = -26, + E_PARTIAL_RESULT = -27, + E_REBUILD_INDEX_FAILED = -28, + E_INVALID_PASSWORD = -29, + E_FAILED_GET_ABS_PATH = -30, + E_BAD_USERNAME_PASSWORD = -1001, + E_SESSION_INVALID = -1002, + E_SESSION_TIMEOUT = -1003, + E_SYNTAX_ERROR = -1004, + E_EXECUTION_ERROR = -1005, + E_STATEMENT_EMPTY = -1006, + E_BAD_PERMISSION = -1008, + E_SEMANTIC_ERROR = -1009, + E_TOO_MANY_CONNECTIONS = -1010, + E_PARTIAL_SUCCEEDED = -1011, + E_NO_HOSTS = -2001, + E_EXISTED = -2002, + E_INVALID_HOST = -2003, + E_UNSUPPORTED = -2004, + E_NOT_DROP = -2005, + E_BALANCER_RUNNING = -2006, + E_CONFIG_IMMUTABLE = -2007, + E_CONFLICT = -2008, + E_INVALID_PARM = -2009, + E_WRONGCLUSTER = -2010, + E_STORE_FAILURE = -2021, + E_STORE_SEGMENT_ILLEGAL = -2022, + E_BAD_BALANCE_PLAN = -2023, + E_BALANCED = -2024, + E_NO_RUNNING_BALANCE_PLAN = -2025, + E_NO_VALID_HOST = -2026, + E_CORRUPTTED_BALANCE_PLAN = -2027, + E_NO_INVALID_BALANCE_PLAN = -2028, + E_IMPROPER_ROLE = -2030, + E_INVALID_PARTITION_NUM = -2031, + E_INVALID_REPLICA_FACTOR = -2032, + E_INVALID_CHARSET = -2033, + E_INVALID_COLLATE = -2034, + E_CHARSET_COLLATE_NOT_MATCH = -2035, + E_SNAPSHOT_FAILURE = -2040, + E_BLOCK_WRITE_FAILURE = -2041, + E_REBUILD_INDEX_FAILURE = -2042, + E_INDEX_WITH_TTL = -2043, + E_ADD_JOB_FAILURE = -2044, + E_STOP_JOB_FAILURE = -2045, + E_SAVE_JOB_FAILURE = -2046, + E_BALANCER_FAILURE = -2047, + E_JOB_NOT_FINISHED = -2048, + E_TASK_REPORT_OUT_DATE = -2049, + E_JOB_NOT_IN_SPACE = -2050, + E_INVALID_JOB = -2065, + E_BACKUP_BUILDING_INDEX = -2066, + E_BACKUP_SPACE_NOT_FOUND = -2067, + E_RESTORE_FAILURE = -2068, + E_SESSION_NOT_FOUND = -2069, + E_LIST_CLUSTER_FAILURE = -2070, + E_LIST_CLUSTER_GET_ABS_PATH_FAILURE = -2071, + E_GET_META_DIR_FAILURE = -2072, + E_QUERY_NOT_FOUND = -2073, + E_CONSENSUS_ERROR = -3001, + E_KEY_HAS_EXISTS = -3002, + E_DATA_TYPE_MISMATCH = -3003, + E_INVALID_FIELD_VALUE = -3004, + E_INVALID_OPERATION = -3005, + E_NOT_NULLABLE = -3006, + E_FIELD_UNSET = -3007, + E_OUT_OF_RANGE = -3008, + E_ATOMIC_OP_FAILED = -3009, + E_DATA_CONFLICT_ERROR = -3010, + E_WRITE_STALLED = -3011, + E_IMPROPER_DATA_TYPE = -3021, + E_INVALID_SPACEVIDLEN = -3022, + E_INVALID_FILTER = -3031, + E_INVALID_UPDATER = -3032, + E_INVALID_STORE = -3033, + E_INVALID_PEER = -3034, + E_RETRY_EXHAUSTED = -3035, + E_TRANSFER_LEADER_FAILED = -3036, + E_INVALID_STAT_TYPE = -3037, + E_INVALID_VID = -3038, + E_NO_TRANSFORMED = -3039, + E_LOAD_META_FAILED = -3040, + E_FAILED_TO_CHECKPOINT = -3041, + E_CHECKPOINT_BLOCKED = -3042, + E_FILTER_OUT = -3043, + E_INVALID_DATA = -3044, + E_MUTATE_EDGE_CONFLICT = -3045, + E_MUTATE_TAG_CONFLICT = -3046, + E_OUTDATED_LOCK = -3047, + E_INVALID_TASK_PARA = -3051, + E_USER_CANCEL = -3052, + E_TASK_EXECUTION_FAILED = -3053, + E_PLAN_IS_KILLED = -3060, + E_NO_TERM = -3070, + E_OUTDATED_TERM = -3071, + E_OUTDATED_EDGE = -3072, + E_WRITE_WRITE_CONFLICT = -3073, + E_CLIENT_SERVER_INCOMPATIBLE = -3061, + E_UNKNOWN = -8000, +}; + + + + +}} // nebula::cpp2 +namespace std { + + +template<> struct hash : public apache::thrift::detail::enum_hash {}; +template<> struct equal_to : public apache::thrift::detail::enum_equal_to {}; + + +template<> struct hash : public apache::thrift::detail::enum_hash {}; +template<> struct equal_to : public apache::thrift::detail::enum_equal_to {}; + + +} // std + +namespace apache { namespace thrift { + + +template <> struct TEnumDataStorage<::nebula::cpp2::NullType>; + +template <> struct TEnumTraits<::nebula::cpp2::NullType> { + using type = ::nebula::cpp2::NullType; + + static constexpr std::size_t const size = 8; + static folly::Range const values; + static folly::Range const names; + + static char const* findName(type value); + static bool findValue(char const* name, type* out); + + static constexpr type min() { return type::__NULL__; } + static constexpr type max() { return type::OUT_OF_RANGE; } +}; + + +template <> struct TEnumDataStorage<::nebula::cpp2::ErrorCode>; + +template <> struct TEnumTraits<::nebula::cpp2::ErrorCode> { + using type = ::nebula::cpp2::ErrorCode; + + static constexpr std::size_t const size = 121; + static folly::Range const values; + static folly::Range const names; + + static char const* findName(type value); + static bool findValue(char const* name, type* out); + + static constexpr type min() { return type::E_UNKNOWN; } + static constexpr type max() { return type::SUCCEEDED; } +}; + + +}} // apache::thrift + +namespace nebula { namespace cpp2 { + +using _NullType_EnumMapFactory = apache::thrift::detail::TEnumMapFactory; +[[deprecated("use apache::thrift::util::enumNameSafe, apache::thrift::util::enumName, or apache::thrift::TEnumTraits")]] +extern const _NullType_EnumMapFactory::ValuesToNamesMapType _NullType_VALUES_TO_NAMES; +[[deprecated("use apache::thrift::TEnumTraits")]] +extern const _NullType_EnumMapFactory::NamesToValuesMapType _NullType_NAMES_TO_VALUES; + +using _ErrorCode_EnumMapFactory = apache::thrift::detail::TEnumMapFactory; +[[deprecated("use apache::thrift::util::enumNameSafe, apache::thrift::util::enumName, or apache::thrift::TEnumTraits")]] +extern const _ErrorCode_EnumMapFactory::ValuesToNamesMapType _ErrorCode_VALUES_TO_NAMES; +[[deprecated("use apache::thrift::TEnumTraits")]] +extern const _ErrorCode_EnumMapFactory::NamesToValuesMapType _ErrorCode_NAMES_TO_VALUES; + +}} // nebula::cpp2 + +// END declare_enums +// BEGIN forward_declare +namespace nebula { namespace cpp2 { +class SchemaID; +class Date; +class Time; +class DateTime; +class Value; +class NList; +class NMap; +class NSet; +class Row; +class DataSet; +class Geography; +class Tag; +class Vertex; +class Edge; +class Step; +class Path; +class HostAddr; +class KeyValue; +class LogInfo; +class DirInfo; +class NodeInfo; +class PartitionBackupInfo; +class CheckpointInfo; +}} // nebula::cpp2 +// END forward_declare +// BEGIN typedefs +namespace nebula { namespace cpp2 { +typedef nebula::GraphSpaceID GraphSpaceID; +typedef nebula::PartitionID PartitionID; +typedef nebula::TagID TagID; +typedef nebula::EdgeType EdgeType; +typedef nebula::EdgeRanking EdgeRanking; +typedef nebula::LogID LogID; +typedef nebula::TermID TermID; +typedef nebula::Timestamp Timestamp; +typedef nebula::IndexID IndexID; +typedef nebula::Port Port; +typedef nebula::SessionID SessionID; +typedef nebula::ExecutionPlanID ExecutionPlanID; + +}} // nebula::cpp2 +// END typedefs +// BEGIN hash_and_equal_to +// END hash_and_equal_to +namespace nebula { namespace cpp2 { +class SchemaID final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = SchemaID; + static constexpr bool __fbthrift_cpp2_is_union = + true; + + + public: + enum Type : int { + __EMPTY__ = 0, + tag_id = 1, + edge_type = 2, + } ; + + SchemaID() + : type_(Type::__EMPTY__) {} + + SchemaID(SchemaID&& rhs) + : type_(Type::__EMPTY__) { + if (this == &rhs) { return; } + if (rhs.type_ == Type::__EMPTY__) { return; } + switch (rhs.type_) { + case Type::tag_id: + { + set_tag_id(std::move(rhs.value_.tag_id)); + break; + } + case Type::edge_type: + { + set_edge_type(std::move(rhs.value_.edge_type)); + break; + } + default: + { + assert(false); + break; + } + } + rhs.__clear(); + } + + SchemaID(const SchemaID& rhs) + : type_(Type::__EMPTY__) { + if (this == &rhs) { return; } + if (rhs.type_ == Type::__EMPTY__) { return; } + switch (rhs.type_) { + case Type::tag_id: + { + set_tag_id(rhs.value_.tag_id); + break; + } + case Type::edge_type: + { + set_edge_type(rhs.value_.edge_type); + break; + } + default: + { + assert(false); + break; + } + } + } + + SchemaID& operator=(SchemaID&& rhs) { + if (this == &rhs) { return *this; } + __clear(); + if (rhs.type_ == Type::__EMPTY__) { return *this; } + switch (rhs.type_) { + case Type::tag_id: + { + set_tag_id(std::move(rhs.value_.tag_id)); + break; + } + case Type::edge_type: + { + set_edge_type(std::move(rhs.value_.edge_type)); + break; + } + default: + { + assert(false); + break; + } + } + rhs.__clear(); + return *this; + } + + SchemaID& operator=(const SchemaID& rhs) { + if (this == &rhs) { return *this; } + __clear(); + if (rhs.type_ == Type::__EMPTY__) { return *this; } + switch (rhs.type_) { + case Type::tag_id: + { + set_tag_id(rhs.value_.tag_id); + break; + } + case Type::edge_type: + { + set_edge_type(rhs.value_.edge_type); + break; + } + default: + { + assert(false); + break; + } + } + return *this; + } + void __clear(); + + ~SchemaID() { + __clear(); + } + union storage_type { + ::nebula::cpp2::TagID tag_id; + ::nebula::cpp2::EdgeType edge_type; + + storage_type() {} + ~storage_type() {} + } ; + bool operator==(const SchemaID& rhs) const; +#ifndef SWIG + friend bool operator!=(const SchemaID& __x, const SchemaID& __y) { + return !(__x == __y); + } +#endif + bool operator<(const SchemaID& rhs) const; +#ifndef SWIG + friend bool operator>(const SchemaID& __x, const SchemaID& __y) { + return __y < __x; + } + friend bool operator<=(const SchemaID& __x, const SchemaID& __y) { + return !(__y < __x); + } + friend bool operator>=(const SchemaID& __x, const SchemaID& __y) { + return !(__x < __y); + } +#endif + + ::nebula::cpp2::TagID& set_tag_id( ::nebula::cpp2::TagID t = ::nebula::cpp2::TagID()) { + __clear(); + type_ = Type::tag_id; + ::new (std::addressof(value_.tag_id)) ::nebula::cpp2::TagID(t); + return value_.tag_id; + } + + ::nebula::cpp2::EdgeType& set_edge_type( ::nebula::cpp2::EdgeType t = ::nebula::cpp2::EdgeType()) { + __clear(); + type_ = Type::edge_type; + ::new (std::addressof(value_.edge_type)) ::nebula::cpp2::EdgeType(t); + return value_.edge_type; + } + + ::nebula::cpp2::TagID const & get_tag_id() const { + assert(type_ == Type::tag_id); + return value_.tag_id; + } + + ::nebula::cpp2::EdgeType const & get_edge_type() const { + assert(type_ == Type::edge_type); + return value_.edge_type; + } + + ::nebula::cpp2::TagID & mutable_tag_id() { + assert(type_ == Type::tag_id); + return value_.tag_id; + } + + ::nebula::cpp2::EdgeType & mutable_edge_type() { + assert(type_ == Type::edge_type); + return value_.edge_type; + } + + ::nebula::cpp2::TagID move_tag_id() { + assert(type_ == Type::tag_id); + return std::move(value_.tag_id); + } + + ::nebula::cpp2::EdgeType move_edge_type() { + assert(type_ == Type::edge_type); + return std::move(value_.edge_type); + } + + template + FOLLY_ERASE ::apache::thrift::union_field_ref tag_id_ref() const& { + return {value_.tag_id, type_, tag_id, this, ::apache::thrift::detail::union_field_ref_owner_vtable_for}; + } + + template + FOLLY_ERASE ::apache::thrift::union_field_ref tag_id_ref() const&& { + return {std::move(value_.tag_id), type_, tag_id, this, ::apache::thrift::detail::union_field_ref_owner_vtable_for}; + } + + template + FOLLY_ERASE ::apache::thrift::union_field_ref tag_id_ref() & { + return {value_.tag_id, type_, tag_id, this, ::apache::thrift::detail::union_field_ref_owner_vtable_for}; + } + + template + FOLLY_ERASE ::apache::thrift::union_field_ref tag_id_ref() && { + return {std::move(value_.tag_id), type_, tag_id, this, ::apache::thrift::detail::union_field_ref_owner_vtable_for}; + } + template + FOLLY_ERASE ::apache::thrift::union_field_ref edge_type_ref() const& { + return {value_.edge_type, type_, edge_type, this, ::apache::thrift::detail::union_field_ref_owner_vtable_for}; + } + + template + FOLLY_ERASE ::apache::thrift::union_field_ref edge_type_ref() const&& { + return {std::move(value_.edge_type), type_, edge_type, this, ::apache::thrift::detail::union_field_ref_owner_vtable_for}; + } + + template + FOLLY_ERASE ::apache::thrift::union_field_ref edge_type_ref() & { + return {value_.edge_type, type_, edge_type, this, ::apache::thrift::detail::union_field_ref_owner_vtable_for}; + } + + template + FOLLY_ERASE ::apache::thrift::union_field_ref edge_type_ref() && { + return {std::move(value_.edge_type), type_, edge_type, this, ::apache::thrift::detail::union_field_ref_owner_vtable_for}; + } + Type getType() const { return static_cast(type_); } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + protected: + template + void destruct(T &val) { + (&val)->~T(); + } + + storage_type value_; + std::underlying_type_t type_; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< SchemaID >; + friend void swap(SchemaID& a, SchemaID& b); +}; + +template +uint32_t SchemaID::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}} // nebula::cpp2 +namespace nebula { namespace cpp2 { +class Date final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = Date; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + Date() : + year(0), + month(0), + day(0) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + Date(apache::thrift::FragileConstructor, int16_t year__arg, int8_t month__arg, int8_t day__arg); + + Date(Date&&) = default; + + Date(const Date&) = default; + + + Date& operator=(Date&&) = default; + + Date& operator=(const Date&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + int16_t year; + private: + int8_t month; + private: + int8_t day; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool year; + bool month; + bool day; + } __isset = {}; + bool operator==(const Date& rhs) const; +#ifndef SWIG + friend bool operator!=(const Date& __x, const Date& __y) { + return !(__x == __y); + } +#endif + bool operator<(const Date& rhs) const; +#ifndef SWIG + friend bool operator>(const Date& __x, const Date& __y) { + return __y < __x; + } + friend bool operator<=(const Date& __x, const Date& __y) { + return !(__y < __x); + } + friend bool operator>=(const Date& __x, const Date& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref year_ref() const& { + return {this->year, __isset.year}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref year_ref() const&& { + return {std::move(this->year), __isset.year}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref year_ref() & { + return {this->year, __isset.year}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref year_ref() && { + return {std::move(this->year), __isset.year}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref month_ref() const& { + return {this->month, __isset.month}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref month_ref() const&& { + return {std::move(this->month), __isset.month}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref month_ref() & { + return {this->month, __isset.month}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref month_ref() && { + return {std::move(this->month), __isset.month}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref day_ref() const& { + return {this->day, __isset.day}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref day_ref() const&& { + return {std::move(this->day), __isset.day}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref day_ref() & { + return {this->day, __isset.day}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref day_ref() && { + return {std::move(this->day), __isset.day}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + int16_t get_year() const { + return year; + } + + int16_t& set_year(int16_t year_) { + year = year_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.year = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return year; + } + + int8_t get_month() const { + return month; + } + + int8_t& set_month(int8_t month_) { + month = month_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.month = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return month; + } + + int8_t get_day() const { + return day; + } + + int8_t& set_day(int8_t day_) { + day = day_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.day = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return day; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< Date >; + friend void swap(Date& a, Date& b); +}; + +template +uint32_t Date::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}} // nebula::cpp2 +namespace nebula { namespace cpp2 { +class Time final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = Time; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + Time() : + hour(0), + minute(0), + sec(0), + microsec(0) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + Time(apache::thrift::FragileConstructor, int8_t hour__arg, int8_t minute__arg, int8_t sec__arg, int32_t microsec__arg); + + Time(Time&&) = default; + + Time(const Time&) = default; + + + Time& operator=(Time&&) = default; + + Time& operator=(const Time&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + int8_t hour; + private: + int8_t minute; + private: + int8_t sec; + private: + int32_t microsec; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool hour; + bool minute; + bool sec; + bool microsec; + } __isset = {}; + bool operator==(const Time& rhs) const; +#ifndef SWIG + friend bool operator!=(const Time& __x, const Time& __y) { + return !(__x == __y); + } +#endif + bool operator<(const Time& rhs) const; +#ifndef SWIG + friend bool operator>(const Time& __x, const Time& __y) { + return __y < __x; + } + friend bool operator<=(const Time& __x, const Time& __y) { + return !(__y < __x); + } + friend bool operator>=(const Time& __x, const Time& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref hour_ref() const& { + return {this->hour, __isset.hour}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref hour_ref() const&& { + return {std::move(this->hour), __isset.hour}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref hour_ref() & { + return {this->hour, __isset.hour}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref hour_ref() && { + return {std::move(this->hour), __isset.hour}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref minute_ref() const& { + return {this->minute, __isset.minute}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref minute_ref() const&& { + return {std::move(this->minute), __isset.minute}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref minute_ref() & { + return {this->minute, __isset.minute}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref minute_ref() && { + return {std::move(this->minute), __isset.minute}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref sec_ref() const& { + return {this->sec, __isset.sec}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref sec_ref() const&& { + return {std::move(this->sec), __isset.sec}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref sec_ref() & { + return {this->sec, __isset.sec}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref sec_ref() && { + return {std::move(this->sec), __isset.sec}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref microsec_ref() const& { + return {this->microsec, __isset.microsec}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref microsec_ref() const&& { + return {std::move(this->microsec), __isset.microsec}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref microsec_ref() & { + return {this->microsec, __isset.microsec}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref microsec_ref() && { + return {std::move(this->microsec), __isset.microsec}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + int8_t get_hour() const { + return hour; + } + + int8_t& set_hour(int8_t hour_) { + hour = hour_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.hour = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return hour; + } + + int8_t get_minute() const { + return minute; + } + + int8_t& set_minute(int8_t minute_) { + minute = minute_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.minute = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return minute; + } + + int8_t get_sec() const { + return sec; + } + + int8_t& set_sec(int8_t sec_) { + sec = sec_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.sec = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return sec; + } + + int32_t get_microsec() const { + return microsec; + } + + int32_t& set_microsec(int32_t microsec_) { + microsec = microsec_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.microsec = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return microsec; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< Time >; + friend void swap(Time& a, Time& b); +}; + +template +uint32_t Time::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}} // nebula::cpp2 +namespace nebula { namespace cpp2 { +class DateTime final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = DateTime; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + DateTime() : + year(0), + month(0), + day(0), + hour(0), + minute(0), + sec(0), + microsec(0) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + DateTime(apache::thrift::FragileConstructor, int16_t year__arg, int8_t month__arg, int8_t day__arg, int8_t hour__arg, int8_t minute__arg, int8_t sec__arg, int32_t microsec__arg); + + DateTime(DateTime&&) = default; + + DateTime(const DateTime&) = default; + + + DateTime& operator=(DateTime&&) = default; + + DateTime& operator=(const DateTime&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + int16_t year; + private: + int8_t month; + private: + int8_t day; + private: + int8_t hour; + private: + int8_t minute; + private: + int8_t sec; + private: + int32_t microsec; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool year; + bool month; + bool day; + bool hour; + bool minute; + bool sec; + bool microsec; + } __isset = {}; + bool operator==(const DateTime& rhs) const; +#ifndef SWIG + friend bool operator!=(const DateTime& __x, const DateTime& __y) { + return !(__x == __y); + } +#endif + bool operator<(const DateTime& rhs) const; +#ifndef SWIG + friend bool operator>(const DateTime& __x, const DateTime& __y) { + return __y < __x; + } + friend bool operator<=(const DateTime& __x, const DateTime& __y) { + return !(__y < __x); + } + friend bool operator>=(const DateTime& __x, const DateTime& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref year_ref() const& { + return {this->year, __isset.year}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref year_ref() const&& { + return {std::move(this->year), __isset.year}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref year_ref() & { + return {this->year, __isset.year}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref year_ref() && { + return {std::move(this->year), __isset.year}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref month_ref() const& { + return {this->month, __isset.month}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref month_ref() const&& { + return {std::move(this->month), __isset.month}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref month_ref() & { + return {this->month, __isset.month}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref month_ref() && { + return {std::move(this->month), __isset.month}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref day_ref() const& { + return {this->day, __isset.day}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref day_ref() const&& { + return {std::move(this->day), __isset.day}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref day_ref() & { + return {this->day, __isset.day}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref day_ref() && { + return {std::move(this->day), __isset.day}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref hour_ref() const& { + return {this->hour, __isset.hour}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref hour_ref() const&& { + return {std::move(this->hour), __isset.hour}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref hour_ref() & { + return {this->hour, __isset.hour}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref hour_ref() && { + return {std::move(this->hour), __isset.hour}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref minute_ref() const& { + return {this->minute, __isset.minute}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref minute_ref() const&& { + return {std::move(this->minute), __isset.minute}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref minute_ref() & { + return {this->minute, __isset.minute}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref minute_ref() && { + return {std::move(this->minute), __isset.minute}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref sec_ref() const& { + return {this->sec, __isset.sec}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref sec_ref() const&& { + return {std::move(this->sec), __isset.sec}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref sec_ref() & { + return {this->sec, __isset.sec}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref sec_ref() && { + return {std::move(this->sec), __isset.sec}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref microsec_ref() const& { + return {this->microsec, __isset.microsec}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref microsec_ref() const&& { + return {std::move(this->microsec), __isset.microsec}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref microsec_ref() & { + return {this->microsec, __isset.microsec}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref microsec_ref() && { + return {std::move(this->microsec), __isset.microsec}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + int16_t get_year() const { + return year; + } + + int16_t& set_year(int16_t year_) { + year = year_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.year = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return year; + } + + int8_t get_month() const { + return month; + } + + int8_t& set_month(int8_t month_) { + month = month_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.month = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return month; + } + + int8_t get_day() const { + return day; + } + + int8_t& set_day(int8_t day_) { + day = day_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.day = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return day; + } + + int8_t get_hour() const { + return hour; + } + + int8_t& set_hour(int8_t hour_) { + hour = hour_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.hour = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return hour; + } + + int8_t get_minute() const { + return minute; + } + + int8_t& set_minute(int8_t minute_) { + minute = minute_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.minute = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return minute; + } + + int8_t get_sec() const { + return sec; + } + + int8_t& set_sec(int8_t sec_) { + sec = sec_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.sec = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return sec; + } + + int32_t get_microsec() const { + return microsec; + } + + int32_t& set_microsec(int32_t microsec_) { + microsec = microsec_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.microsec = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return microsec; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< DateTime >; + friend void swap(DateTime& a, DateTime& b); +}; + +template +uint32_t DateTime::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}} // nebula::cpp2 +namespace nebula { namespace cpp2 { +class Value final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = Value; + static constexpr bool __fbthrift_cpp2_is_union = + true; + + + public: + enum Type : int { + __EMPTY__ = 0, + nVal = 1, + bVal = 2, + iVal = 3, + fVal = 4, + sVal = 5, + dVal = 6, + tVal = 7, + dtVal = 8, + vVal = 9, + eVal = 10, + pVal = 11, + lVal = 12, + mVal = 13, + uVal = 14, + gVal = 15, + ggVal = 16, + } ; + + Value() + : type_(Type::__EMPTY__) {} + + Value(Value&& rhs) + : type_(Type::__EMPTY__) { + if (this == &rhs) { return; } + if (rhs.type_ == Type::__EMPTY__) { return; } + switch (rhs.type_) { + case Type::nVal: + { + set_nVal(std::move(rhs.value_.nVal)); + break; + } + case Type::bVal: + { + set_bVal(std::move(rhs.value_.bVal)); + break; + } + case Type::iVal: + { + set_iVal(std::move(rhs.value_.iVal)); + break; + } + case Type::fVal: + { + set_fVal(std::move(rhs.value_.fVal)); + break; + } + case Type::sVal: + { + set_sVal(std::move(rhs.value_.sVal)); + break; + } + case Type::dVal: + { + set_dVal(std::move(rhs.value_.dVal)); + break; + } + case Type::tVal: + { + set_tVal(std::move(rhs.value_.tVal)); + break; + } + case Type::dtVal: + { + set_dtVal(std::move(rhs.value_.dtVal)); + break; + } + case Type::vVal: + { + set_vVal(std::move(*rhs.value_.vVal)); + break; + } + case Type::eVal: + { + set_eVal(std::move(*rhs.value_.eVal)); + break; + } + case Type::pVal: + { + set_pVal(std::move(*rhs.value_.pVal)); + break; + } + case Type::lVal: + { + set_lVal(std::move(*rhs.value_.lVal)); + break; + } + case Type::mVal: + { + set_mVal(std::move(*rhs.value_.mVal)); + break; + } + case Type::uVal: + { + set_uVal(std::move(*rhs.value_.uVal)); + break; + } + case Type::gVal: + { + set_gVal(std::move(*rhs.value_.gVal)); + break; + } + case Type::ggVal: + { + set_ggVal(std::move(*rhs.value_.ggVal)); + break; + } + default: + { + assert(false); + break; + } + } + rhs.__clear(); + } + + Value(const Value& rhs) + : type_(Type::__EMPTY__) { + if (this == &rhs) { return; } + if (rhs.type_ == Type::__EMPTY__) { return; } + switch (rhs.type_) { + case Type::nVal: + { + set_nVal(rhs.value_.nVal); + break; + } + case Type::bVal: + { + set_bVal(rhs.value_.bVal); + break; + } + case Type::iVal: + { + set_iVal(rhs.value_.iVal); + break; + } + case Type::fVal: + { + set_fVal(rhs.value_.fVal); + break; + } + case Type::sVal: + { + set_sVal(rhs.value_.sVal); + break; + } + case Type::dVal: + { + set_dVal(rhs.value_.dVal); + break; + } + case Type::tVal: + { + set_tVal(rhs.value_.tVal); + break; + } + case Type::dtVal: + { + set_dtVal(rhs.value_.dtVal); + break; + } + case Type::vVal: + { + set_vVal(*rhs.value_.vVal); + break; + } + case Type::eVal: + { + set_eVal(*rhs.value_.eVal); + break; + } + case Type::pVal: + { + set_pVal(*rhs.value_.pVal); + break; + } + case Type::lVal: + { + set_lVal(*rhs.value_.lVal); + break; + } + case Type::mVal: + { + set_mVal(*rhs.value_.mVal); + break; + } + case Type::uVal: + { + set_uVal(*rhs.value_.uVal); + break; + } + case Type::gVal: + { + set_gVal(*rhs.value_.gVal); + break; + } + case Type::ggVal: + { + set_ggVal(*rhs.value_.ggVal); + break; + } + default: + { + assert(false); + break; + } + } + } + + Value& operator=(Value&& rhs) { + if (this == &rhs) { return *this; } + __clear(); + if (rhs.type_ == Type::__EMPTY__) { return *this; } + switch (rhs.type_) { + case Type::nVal: + { + set_nVal(std::move(rhs.value_.nVal)); + break; + } + case Type::bVal: + { + set_bVal(std::move(rhs.value_.bVal)); + break; + } + case Type::iVal: + { + set_iVal(std::move(rhs.value_.iVal)); + break; + } + case Type::fVal: + { + set_fVal(std::move(rhs.value_.fVal)); + break; + } + case Type::sVal: + { + set_sVal(std::move(rhs.value_.sVal)); + break; + } + case Type::dVal: + { + set_dVal(std::move(rhs.value_.dVal)); + break; + } + case Type::tVal: + { + set_tVal(std::move(rhs.value_.tVal)); + break; + } + case Type::dtVal: + { + set_dtVal(std::move(rhs.value_.dtVal)); + break; + } + case Type::vVal: + { + set_vVal(std::move(*rhs.value_.vVal)); + break; + } + case Type::eVal: + { + set_eVal(std::move(*rhs.value_.eVal)); + break; + } + case Type::pVal: + { + set_pVal(std::move(*rhs.value_.pVal)); + break; + } + case Type::lVal: + { + set_lVal(std::move(*rhs.value_.lVal)); + break; + } + case Type::mVal: + { + set_mVal(std::move(*rhs.value_.mVal)); + break; + } + case Type::uVal: + { + set_uVal(std::move(*rhs.value_.uVal)); + break; + } + case Type::gVal: + { + set_gVal(std::move(*rhs.value_.gVal)); + break; + } + case Type::ggVal: + { + set_ggVal(std::move(*rhs.value_.ggVal)); + break; + } + default: + { + assert(false); + break; + } + } + rhs.__clear(); + return *this; + } + + Value& operator=(const Value& rhs) { + if (this == &rhs) { return *this; } + __clear(); + if (rhs.type_ == Type::__EMPTY__) { return *this; } + switch (rhs.type_) { + case Type::nVal: + { + set_nVal(rhs.value_.nVal); + break; + } + case Type::bVal: + { + set_bVal(rhs.value_.bVal); + break; + } + case Type::iVal: + { + set_iVal(rhs.value_.iVal); + break; + } + case Type::fVal: + { + set_fVal(rhs.value_.fVal); + break; + } + case Type::sVal: + { + set_sVal(rhs.value_.sVal); + break; + } + case Type::dVal: + { + set_dVal(rhs.value_.dVal); + break; + } + case Type::tVal: + { + set_tVal(rhs.value_.tVal); + break; + } + case Type::dtVal: + { + set_dtVal(rhs.value_.dtVal); + break; + } + case Type::vVal: + { + set_vVal(*rhs.value_.vVal); + break; + } + case Type::eVal: + { + set_eVal(*rhs.value_.eVal); + break; + } + case Type::pVal: + { + set_pVal(*rhs.value_.pVal); + break; + } + case Type::lVal: + { + set_lVal(*rhs.value_.lVal); + break; + } + case Type::mVal: + { + set_mVal(*rhs.value_.mVal); + break; + } + case Type::uVal: + { + set_uVal(*rhs.value_.uVal); + break; + } + case Type::gVal: + { + set_gVal(*rhs.value_.gVal); + break; + } + case Type::ggVal: + { + set_ggVal(*rhs.value_.ggVal); + break; + } + default: + { + assert(false); + break; + } + } + return *this; + } + void __clear(); + + ~Value() { + __clear(); + } + union storage_type { + nebula::NullType nVal; + bool bVal; + int64_t iVal; + double fVal; + ::std::string sVal; + nebula::Date dVal; + nebula::Time tVal; + nebula::DateTime dtVal; + std::unique_ptr vVal; + std::unique_ptr eVal; + std::unique_ptr pVal; + std::unique_ptr lVal; + std::unique_ptr mVal; + std::unique_ptr uVal; + std::unique_ptr gVal; + std::unique_ptr ggVal; + + storage_type() {} + ~storage_type() {} + } ; + bool operator==(const Value& rhs) const; +#ifndef SWIG + friend bool operator!=(const Value& __x, const Value& __y) { + return !(__x == __y); + } +#endif + bool operator<(const Value& rhs) const; +#ifndef SWIG + friend bool operator>(const Value& __x, const Value& __y) { + return __y < __x; + } + friend bool operator<=(const Value& __x, const Value& __y) { + return !(__y < __x); + } + friend bool operator>=(const Value& __x, const Value& __y) { + return !(__x < __y); + } +#endif + + nebula::NullType& set_nVal(nebula::NullType t = nebula::NullType()) { + __clear(); + type_ = Type::nVal; + ::new (std::addressof(value_.nVal)) nebula::NullType(t); + return value_.nVal; + } + + bool& set_bVal(bool t = bool()) { + __clear(); + type_ = Type::bVal; + ::new (std::addressof(value_.bVal)) bool(t); + return value_.bVal; + } + + int64_t& set_iVal(int64_t t = int64_t()) { + __clear(); + type_ = Type::iVal; + ::new (std::addressof(value_.iVal)) int64_t(t); + return value_.iVal; + } + + double& set_fVal(double t = double()) { + __clear(); + type_ = Type::fVal; + ::new (std::addressof(value_.fVal)) double(t); + return value_.fVal; + } + + ::std::string& set_sVal(::std::string const &t) { + __clear(); + type_ = Type::sVal; + ::new (std::addressof(value_.sVal)) ::std::string(t); + return value_.sVal; + } + + ::std::string& set_sVal(::std::string&& t) { + __clear(); + type_ = Type::sVal; + ::new (std::addressof(value_.sVal)) ::std::string(std::move(t)); + return value_.sVal; + } + + template> ::std::string& set_sVal(T&&... t) { + __clear(); + type_ = Type::sVal; + ::new (std::addressof(value_.sVal)) ::std::string(std::forward(t)...); + return value_.sVal; + } + + nebula::Date& set_dVal(nebula::Date const &t) { + __clear(); + type_ = Type::dVal; + ::new (std::addressof(value_.dVal)) nebula::Date(t); + return value_.dVal; + } + + nebula::Date& set_dVal(nebula::Date&& t) { + __clear(); + type_ = Type::dVal; + ::new (std::addressof(value_.dVal)) nebula::Date(std::move(t)); + return value_.dVal; + } + + template> nebula::Date& set_dVal(T&&... t) { + __clear(); + type_ = Type::dVal; + ::new (std::addressof(value_.dVal)) nebula::Date(std::forward(t)...); + return value_.dVal; + } + + nebula::Time& set_tVal(nebula::Time const &t) { + __clear(); + type_ = Type::tVal; + ::new (std::addressof(value_.tVal)) nebula::Time(t); + return value_.tVal; + } + + nebula::Time& set_tVal(nebula::Time&& t) { + __clear(); + type_ = Type::tVal; + ::new (std::addressof(value_.tVal)) nebula::Time(std::move(t)); + return value_.tVal; + } + + template> nebula::Time& set_tVal(T&&... t) { + __clear(); + type_ = Type::tVal; + ::new (std::addressof(value_.tVal)) nebula::Time(std::forward(t)...); + return value_.tVal; + } + + nebula::DateTime& set_dtVal(nebula::DateTime const &t) { + __clear(); + type_ = Type::dtVal; + ::new (std::addressof(value_.dtVal)) nebula::DateTime(t); + return value_.dtVal; + } + + nebula::DateTime& set_dtVal(nebula::DateTime&& t) { + __clear(); + type_ = Type::dtVal; + ::new (std::addressof(value_.dtVal)) nebula::DateTime(std::move(t)); + return value_.dtVal; + } + + template> nebula::DateTime& set_dtVal(T&&... t) { + __clear(); + type_ = Type::dtVal; + ::new (std::addressof(value_.dtVal)) nebula::DateTime(std::forward(t)...); + return value_.dtVal; + } + std::unique_ptr& set_vVal(nebula::Vertex const &t); + std::unique_ptr& set_vVal(nebula::Vertex&& t); + template> std::unique_ptr& set_vVal(T&&... t) { + // defer resolution of ref_ in case ref_::element_type would here be incomplete + using ref_ = folly::conditional_t<(sizeof...(T) < size_t(-1)), std::unique_ptr, void>; + __clear(); + type_ = Type::vVal; + ::new (std::addressof(value_.vVal)) ref_(new typename ref_::element_type(std::forward(t)...)); + return value_.vVal; + } + std::unique_ptr& set_eVal(nebula::Edge const &t); + std::unique_ptr& set_eVal(nebula::Edge&& t); + template> std::unique_ptr& set_eVal(T&&... t) { + // defer resolution of ref_ in case ref_::element_type would here be incomplete + using ref_ = folly::conditional_t<(sizeof...(T) < size_t(-1)), std::unique_ptr, void>; + __clear(); + type_ = Type::eVal; + ::new (std::addressof(value_.eVal)) ref_(new typename ref_::element_type(std::forward(t)...)); + return value_.eVal; + } + std::unique_ptr& set_pVal(nebula::Path const &t); + std::unique_ptr& set_pVal(nebula::Path&& t); + template> std::unique_ptr& set_pVal(T&&... t) { + // defer resolution of ref_ in case ref_::element_type would here be incomplete + using ref_ = folly::conditional_t<(sizeof...(T) < size_t(-1)), std::unique_ptr, void>; + __clear(); + type_ = Type::pVal; + ::new (std::addressof(value_.pVal)) ref_(new typename ref_::element_type(std::forward(t)...)); + return value_.pVal; + } + std::unique_ptr& set_lVal(nebula::List const &t); + std::unique_ptr& set_lVal(nebula::List&& t); + template> std::unique_ptr& set_lVal(T&&... t) { + // defer resolution of ref_ in case ref_::element_type would here be incomplete + using ref_ = folly::conditional_t<(sizeof...(T) < size_t(-1)), std::unique_ptr, void>; + __clear(); + type_ = Type::lVal; + ::new (std::addressof(value_.lVal)) ref_(new typename ref_::element_type(std::forward(t)...)); + return value_.lVal; + } + std::unique_ptr& set_mVal(nebula::Map const &t); + std::unique_ptr& set_mVal(nebula::Map&& t); + template> std::unique_ptr& set_mVal(T&&... t) { + // defer resolution of ref_ in case ref_::element_type would here be incomplete + using ref_ = folly::conditional_t<(sizeof...(T) < size_t(-1)), std::unique_ptr, void>; + __clear(); + type_ = Type::mVal; + ::new (std::addressof(value_.mVal)) ref_(new typename ref_::element_type(std::forward(t)...)); + return value_.mVal; + } + std::unique_ptr& set_uVal(nebula::Set const &t); + std::unique_ptr& set_uVal(nebula::Set&& t); + template> std::unique_ptr& set_uVal(T&&... t) { + // defer resolution of ref_ in case ref_::element_type would here be incomplete + using ref_ = folly::conditional_t<(sizeof...(T) < size_t(-1)), std::unique_ptr, void>; + __clear(); + type_ = Type::uVal; + ::new (std::addressof(value_.uVal)) ref_(new typename ref_::element_type(std::forward(t)...)); + return value_.uVal; + } + std::unique_ptr& set_gVal(nebula::DataSet const &t); + std::unique_ptr& set_gVal(nebula::DataSet&& t); + template> std::unique_ptr& set_gVal(T&&... t) { + // defer resolution of ref_ in case ref_::element_type would here be incomplete + using ref_ = folly::conditional_t<(sizeof...(T) < size_t(-1)), std::unique_ptr, void>; + __clear(); + type_ = Type::gVal; + ::new (std::addressof(value_.gVal)) ref_(new typename ref_::element_type(std::forward(t)...)); + return value_.gVal; + } + std::unique_ptr& set_ggVal(nebula::Geography const &t); + std::unique_ptr& set_ggVal(nebula::Geography&& t); + template> std::unique_ptr& set_ggVal(T&&... t) { + // defer resolution of ref_ in case ref_::element_type would here be incomplete + using ref_ = folly::conditional_t<(sizeof...(T) < size_t(-1)), std::unique_ptr, void>; + __clear(); + type_ = Type::ggVal; + ::new (std::addressof(value_.ggVal)) ref_(new typename ref_::element_type(std::forward(t)...)); + return value_.ggVal; + } + + nebula::NullType const & get_nVal() const { + assert(type_ == Type::nVal); + return value_.nVal; + } + + bool const & get_bVal() const { + assert(type_ == Type::bVal); + return value_.bVal; + } + + int64_t const & get_iVal() const { + assert(type_ == Type::iVal); + return value_.iVal; + } + + double const & get_fVal() const { + assert(type_ == Type::fVal); + return value_.fVal; + } + + ::std::string const & get_sVal() const { + assert(type_ == Type::sVal); + return value_.sVal; + } + + nebula::Date const & get_dVal() const { + assert(type_ == Type::dVal); + return value_.dVal; + } + + nebula::Time const & get_tVal() const { + assert(type_ == Type::tVal); + return value_.tVal; + } + + nebula::DateTime const & get_dtVal() const { + assert(type_ == Type::dtVal); + return value_.dtVal; + } + + std::unique_ptr const & get_vVal() const { + assert(type_ == Type::vVal); + return value_.vVal; + } + + std::unique_ptr const & get_eVal() const { + assert(type_ == Type::eVal); + return value_.eVal; + } + + std::unique_ptr const & get_pVal() const { + assert(type_ == Type::pVal); + return value_.pVal; + } + + std::unique_ptr const & get_lVal() const { + assert(type_ == Type::lVal); + return value_.lVal; + } + + std::unique_ptr const & get_mVal() const { + assert(type_ == Type::mVal); + return value_.mVal; + } + + std::unique_ptr const & get_uVal() const { + assert(type_ == Type::uVal); + return value_.uVal; + } + + std::unique_ptr const & get_gVal() const { + assert(type_ == Type::gVal); + return value_.gVal; + } + + std::unique_ptr const & get_ggVal() const { + assert(type_ == Type::ggVal); + return value_.ggVal; + } + + nebula::NullType & mutable_nVal() { + assert(type_ == Type::nVal); + return value_.nVal; + } + + bool & mutable_bVal() { + assert(type_ == Type::bVal); + return value_.bVal; + } + + int64_t & mutable_iVal() { + assert(type_ == Type::iVal); + return value_.iVal; + } + + double & mutable_fVal() { + assert(type_ == Type::fVal); + return value_.fVal; + } + + ::std::string & mutable_sVal() { + assert(type_ == Type::sVal); + return value_.sVal; + } + + nebula::Date & mutable_dVal() { + assert(type_ == Type::dVal); + return value_.dVal; + } + + nebula::Time & mutable_tVal() { + assert(type_ == Type::tVal); + return value_.tVal; + } + + nebula::DateTime & mutable_dtVal() { + assert(type_ == Type::dtVal); + return value_.dtVal; + } + + std::unique_ptr & mutable_vVal() { + assert(type_ == Type::vVal); + return value_.vVal; + } + + std::unique_ptr & mutable_eVal() { + assert(type_ == Type::eVal); + return value_.eVal; + } + + std::unique_ptr & mutable_pVal() { + assert(type_ == Type::pVal); + return value_.pVal; + } + + std::unique_ptr & mutable_lVal() { + assert(type_ == Type::lVal); + return value_.lVal; + } + + std::unique_ptr & mutable_mVal() { + assert(type_ == Type::mVal); + return value_.mVal; + } + + std::unique_ptr & mutable_uVal() { + assert(type_ == Type::uVal); + return value_.uVal; + } + + std::unique_ptr & mutable_gVal() { + assert(type_ == Type::gVal); + return value_.gVal; + } + + std::unique_ptr & mutable_ggVal() { + assert(type_ == Type::ggVal); + return value_.ggVal; + } + + nebula::NullType move_nVal() { + assert(type_ == Type::nVal); + return std::move(value_.nVal); + } + + bool move_bVal() { + assert(type_ == Type::bVal); + return std::move(value_.bVal); + } + + int64_t move_iVal() { + assert(type_ == Type::iVal); + return std::move(value_.iVal); + } + + double move_fVal() { + assert(type_ == Type::fVal); + return std::move(value_.fVal); + } + + ::std::string move_sVal() { + assert(type_ == Type::sVal); + return std::move(value_.sVal); + } + + nebula::Date move_dVal() { + assert(type_ == Type::dVal); + return std::move(value_.dVal); + } + + nebula::Time move_tVal() { + assert(type_ == Type::tVal); + return std::move(value_.tVal); + } + + nebula::DateTime move_dtVal() { + assert(type_ == Type::dtVal); + return std::move(value_.dtVal); + } + + std::unique_ptr move_vVal() { + assert(type_ == Type::vVal); + return std::move(value_.vVal); + } + + std::unique_ptr move_eVal() { + assert(type_ == Type::eVal); + return std::move(value_.eVal); + } + + std::unique_ptr move_pVal() { + assert(type_ == Type::pVal); + return std::move(value_.pVal); + } + + std::unique_ptr move_lVal() { + assert(type_ == Type::lVal); + return std::move(value_.lVal); + } + + std::unique_ptr move_mVal() { + assert(type_ == Type::mVal); + return std::move(value_.mVal); + } + + std::unique_ptr move_uVal() { + assert(type_ == Type::uVal); + return std::move(value_.uVal); + } + + std::unique_ptr move_gVal() { + assert(type_ == Type::gVal); + return std::move(value_.gVal); + } + + std::unique_ptr move_ggVal() { + assert(type_ == Type::ggVal); + return std::move(value_.ggVal); + } + + template + FOLLY_ERASE ::apache::thrift::union_field_ref nVal_ref() const& { + return {value_.nVal, type_, nVal, this, ::apache::thrift::detail::union_field_ref_owner_vtable_for}; + } + + template + FOLLY_ERASE ::apache::thrift::union_field_ref nVal_ref() const&& { + return {std::move(value_.nVal), type_, nVal, this, ::apache::thrift::detail::union_field_ref_owner_vtable_for}; + } + + template + FOLLY_ERASE ::apache::thrift::union_field_ref nVal_ref() & { + return {value_.nVal, type_, nVal, this, ::apache::thrift::detail::union_field_ref_owner_vtable_for}; + } + + template + FOLLY_ERASE ::apache::thrift::union_field_ref nVal_ref() && { + return {std::move(value_.nVal), type_, nVal, this, ::apache::thrift::detail::union_field_ref_owner_vtable_for}; + } + template + FOLLY_ERASE ::apache::thrift::union_field_ref bVal_ref() const& { + return {value_.bVal, type_, bVal, this, ::apache::thrift::detail::union_field_ref_owner_vtable_for}; + } + + template + FOLLY_ERASE ::apache::thrift::union_field_ref bVal_ref() const&& { + return {std::move(value_.bVal), type_, bVal, this, ::apache::thrift::detail::union_field_ref_owner_vtable_for}; + } + + template + FOLLY_ERASE ::apache::thrift::union_field_ref bVal_ref() & { + return {value_.bVal, type_, bVal, this, ::apache::thrift::detail::union_field_ref_owner_vtable_for}; + } + + template + FOLLY_ERASE ::apache::thrift::union_field_ref bVal_ref() && { + return {std::move(value_.bVal), type_, bVal, this, ::apache::thrift::detail::union_field_ref_owner_vtable_for}; + } + template + FOLLY_ERASE ::apache::thrift::union_field_ref iVal_ref() const& { + return {value_.iVal, type_, iVal, this, ::apache::thrift::detail::union_field_ref_owner_vtable_for}; + } + + template + FOLLY_ERASE ::apache::thrift::union_field_ref iVal_ref() const&& { + return {std::move(value_.iVal), type_, iVal, this, ::apache::thrift::detail::union_field_ref_owner_vtable_for}; + } + + template + FOLLY_ERASE ::apache::thrift::union_field_ref iVal_ref() & { + return {value_.iVal, type_, iVal, this, ::apache::thrift::detail::union_field_ref_owner_vtable_for}; + } + + template + FOLLY_ERASE ::apache::thrift::union_field_ref iVal_ref() && { + return {std::move(value_.iVal), type_, iVal, this, ::apache::thrift::detail::union_field_ref_owner_vtable_for}; + } + template + FOLLY_ERASE ::apache::thrift::union_field_ref fVal_ref() const& { + return {value_.fVal, type_, fVal, this, ::apache::thrift::detail::union_field_ref_owner_vtable_for}; + } + + template + FOLLY_ERASE ::apache::thrift::union_field_ref fVal_ref() const&& { + return {std::move(value_.fVal), type_, fVal, this, ::apache::thrift::detail::union_field_ref_owner_vtable_for}; + } + + template + FOLLY_ERASE ::apache::thrift::union_field_ref fVal_ref() & { + return {value_.fVal, type_, fVal, this, ::apache::thrift::detail::union_field_ref_owner_vtable_for}; + } + + template + FOLLY_ERASE ::apache::thrift::union_field_ref fVal_ref() && { + return {std::move(value_.fVal), type_, fVal, this, ::apache::thrift::detail::union_field_ref_owner_vtable_for}; + } + template + FOLLY_ERASE ::apache::thrift::union_field_ref sVal_ref() const& { + return {value_.sVal, type_, sVal, this, ::apache::thrift::detail::union_field_ref_owner_vtable_for}; + } + + template + FOLLY_ERASE ::apache::thrift::union_field_ref sVal_ref() const&& { + return {std::move(value_.sVal), type_, sVal, this, ::apache::thrift::detail::union_field_ref_owner_vtable_for}; + } + + template + FOLLY_ERASE ::apache::thrift::union_field_ref sVal_ref() & { + return {value_.sVal, type_, sVal, this, ::apache::thrift::detail::union_field_ref_owner_vtable_for}; + } + + template + FOLLY_ERASE ::apache::thrift::union_field_ref sVal_ref() && { + return {std::move(value_.sVal), type_, sVal, this, ::apache::thrift::detail::union_field_ref_owner_vtable_for}; + } + template + FOLLY_ERASE ::apache::thrift::union_field_ref dVal_ref() const& { + return {value_.dVal, type_, dVal, this, ::apache::thrift::detail::union_field_ref_owner_vtable_for}; + } + + template + FOLLY_ERASE ::apache::thrift::union_field_ref dVal_ref() const&& { + return {std::move(value_.dVal), type_, dVal, this, ::apache::thrift::detail::union_field_ref_owner_vtable_for}; + } + + template + FOLLY_ERASE ::apache::thrift::union_field_ref dVal_ref() & { + return {value_.dVal, type_, dVal, this, ::apache::thrift::detail::union_field_ref_owner_vtable_for}; + } + + template + FOLLY_ERASE ::apache::thrift::union_field_ref dVal_ref() && { + return {std::move(value_.dVal), type_, dVal, this, ::apache::thrift::detail::union_field_ref_owner_vtable_for}; + } + template + FOLLY_ERASE ::apache::thrift::union_field_ref tVal_ref() const& { + return {value_.tVal, type_, tVal, this, ::apache::thrift::detail::union_field_ref_owner_vtable_for}; + } + + template + FOLLY_ERASE ::apache::thrift::union_field_ref tVal_ref() const&& { + return {std::move(value_.tVal), type_, tVal, this, ::apache::thrift::detail::union_field_ref_owner_vtable_for}; + } + + template + FOLLY_ERASE ::apache::thrift::union_field_ref tVal_ref() & { + return {value_.tVal, type_, tVal, this, ::apache::thrift::detail::union_field_ref_owner_vtable_for}; + } + + template + FOLLY_ERASE ::apache::thrift::union_field_ref tVal_ref() && { + return {std::move(value_.tVal), type_, tVal, this, ::apache::thrift::detail::union_field_ref_owner_vtable_for}; + } + template + FOLLY_ERASE ::apache::thrift::union_field_ref dtVal_ref() const& { + return {value_.dtVal, type_, dtVal, this, ::apache::thrift::detail::union_field_ref_owner_vtable_for}; + } + + template + FOLLY_ERASE ::apache::thrift::union_field_ref dtVal_ref() const&& { + return {std::move(value_.dtVal), type_, dtVal, this, ::apache::thrift::detail::union_field_ref_owner_vtable_for}; + } + + template + FOLLY_ERASE ::apache::thrift::union_field_ref dtVal_ref() & { + return {value_.dtVal, type_, dtVal, this, ::apache::thrift::detail::union_field_ref_owner_vtable_for}; + } + + template + FOLLY_ERASE ::apache::thrift::union_field_ref dtVal_ref() && { + return {std::move(value_.dtVal), type_, dtVal, this, ::apache::thrift::detail::union_field_ref_owner_vtable_for}; + } + template + FOLLY_ERASE ::apache::thrift::union_field_ref vVal_ref() const& { + return {value_.vVal, type_, vVal, this, ::apache::thrift::detail::union_field_ref_owner_vtable_for}; + } + + template + FOLLY_ERASE ::apache::thrift::union_field_ref vVal_ref() const&& { + return {std::move(value_.vVal), type_, vVal, this, ::apache::thrift::detail::union_field_ref_owner_vtable_for}; + } + + template + FOLLY_ERASE ::apache::thrift::union_field_ref vVal_ref() & { + return {value_.vVal, type_, vVal, this, ::apache::thrift::detail::union_field_ref_owner_vtable_for}; + } + + template + FOLLY_ERASE ::apache::thrift::union_field_ref vVal_ref() && { + return {std::move(value_.vVal), type_, vVal, this, ::apache::thrift::detail::union_field_ref_owner_vtable_for}; + } + template + FOLLY_ERASE ::apache::thrift::union_field_ref eVal_ref() const& { + return {value_.eVal, type_, eVal, this, ::apache::thrift::detail::union_field_ref_owner_vtable_for}; + } + + template + FOLLY_ERASE ::apache::thrift::union_field_ref eVal_ref() const&& { + return {std::move(value_.eVal), type_, eVal, this, ::apache::thrift::detail::union_field_ref_owner_vtable_for}; + } + + template + FOLLY_ERASE ::apache::thrift::union_field_ref eVal_ref() & { + return {value_.eVal, type_, eVal, this, ::apache::thrift::detail::union_field_ref_owner_vtable_for}; + } + + template + FOLLY_ERASE ::apache::thrift::union_field_ref eVal_ref() && { + return {std::move(value_.eVal), type_, eVal, this, ::apache::thrift::detail::union_field_ref_owner_vtable_for}; + } + template + FOLLY_ERASE ::apache::thrift::union_field_ref pVal_ref() const& { + return {value_.pVal, type_, pVal, this, ::apache::thrift::detail::union_field_ref_owner_vtable_for}; + } + + template + FOLLY_ERASE ::apache::thrift::union_field_ref pVal_ref() const&& { + return {std::move(value_.pVal), type_, pVal, this, ::apache::thrift::detail::union_field_ref_owner_vtable_for}; + } + + template + FOLLY_ERASE ::apache::thrift::union_field_ref pVal_ref() & { + return {value_.pVal, type_, pVal, this, ::apache::thrift::detail::union_field_ref_owner_vtable_for}; + } + + template + FOLLY_ERASE ::apache::thrift::union_field_ref pVal_ref() && { + return {std::move(value_.pVal), type_, pVal, this, ::apache::thrift::detail::union_field_ref_owner_vtable_for}; + } + template + FOLLY_ERASE ::apache::thrift::union_field_ref lVal_ref() const& { + return {value_.lVal, type_, lVal, this, ::apache::thrift::detail::union_field_ref_owner_vtable_for}; + } + + template + FOLLY_ERASE ::apache::thrift::union_field_ref lVal_ref() const&& { + return {std::move(value_.lVal), type_, lVal, this, ::apache::thrift::detail::union_field_ref_owner_vtable_for}; + } + + template + FOLLY_ERASE ::apache::thrift::union_field_ref lVal_ref() & { + return {value_.lVal, type_, lVal, this, ::apache::thrift::detail::union_field_ref_owner_vtable_for}; + } + + template + FOLLY_ERASE ::apache::thrift::union_field_ref lVal_ref() && { + return {std::move(value_.lVal), type_, lVal, this, ::apache::thrift::detail::union_field_ref_owner_vtable_for}; + } + template + FOLLY_ERASE ::apache::thrift::union_field_ref mVal_ref() const& { + return {value_.mVal, type_, mVal, this, ::apache::thrift::detail::union_field_ref_owner_vtable_for}; + } + + template + FOLLY_ERASE ::apache::thrift::union_field_ref mVal_ref() const&& { + return {std::move(value_.mVal), type_, mVal, this, ::apache::thrift::detail::union_field_ref_owner_vtable_for}; + } + + template + FOLLY_ERASE ::apache::thrift::union_field_ref mVal_ref() & { + return {value_.mVal, type_, mVal, this, ::apache::thrift::detail::union_field_ref_owner_vtable_for}; + } + + template + FOLLY_ERASE ::apache::thrift::union_field_ref mVal_ref() && { + return {std::move(value_.mVal), type_, mVal, this, ::apache::thrift::detail::union_field_ref_owner_vtable_for}; + } + template + FOLLY_ERASE ::apache::thrift::union_field_ref uVal_ref() const& { + return {value_.uVal, type_, uVal, this, ::apache::thrift::detail::union_field_ref_owner_vtable_for}; + } + + template + FOLLY_ERASE ::apache::thrift::union_field_ref uVal_ref() const&& { + return {std::move(value_.uVal), type_, uVal, this, ::apache::thrift::detail::union_field_ref_owner_vtable_for}; + } + + template + FOLLY_ERASE ::apache::thrift::union_field_ref uVal_ref() & { + return {value_.uVal, type_, uVal, this, ::apache::thrift::detail::union_field_ref_owner_vtable_for}; + } + + template + FOLLY_ERASE ::apache::thrift::union_field_ref uVal_ref() && { + return {std::move(value_.uVal), type_, uVal, this, ::apache::thrift::detail::union_field_ref_owner_vtable_for}; + } + template + FOLLY_ERASE ::apache::thrift::union_field_ref gVal_ref() const& { + return {value_.gVal, type_, gVal, this, ::apache::thrift::detail::union_field_ref_owner_vtable_for}; + } + + template + FOLLY_ERASE ::apache::thrift::union_field_ref gVal_ref() const&& { + return {std::move(value_.gVal), type_, gVal, this, ::apache::thrift::detail::union_field_ref_owner_vtable_for}; + } + + template + FOLLY_ERASE ::apache::thrift::union_field_ref gVal_ref() & { + return {value_.gVal, type_, gVal, this, ::apache::thrift::detail::union_field_ref_owner_vtable_for}; + } + + template + FOLLY_ERASE ::apache::thrift::union_field_ref gVal_ref() && { + return {std::move(value_.gVal), type_, gVal, this, ::apache::thrift::detail::union_field_ref_owner_vtable_for}; + } + template + FOLLY_ERASE ::apache::thrift::union_field_ref ggVal_ref() const& { + return {value_.ggVal, type_, ggVal, this, ::apache::thrift::detail::union_field_ref_owner_vtable_for}; + } + + template + FOLLY_ERASE ::apache::thrift::union_field_ref ggVal_ref() const&& { + return {std::move(value_.ggVal), type_, ggVal, this, ::apache::thrift::detail::union_field_ref_owner_vtable_for}; + } + + template + FOLLY_ERASE ::apache::thrift::union_field_ref ggVal_ref() & { + return {value_.ggVal, type_, ggVal, this, ::apache::thrift::detail::union_field_ref_owner_vtable_for}; + } + + template + FOLLY_ERASE ::apache::thrift::union_field_ref ggVal_ref() && { + return {std::move(value_.ggVal), type_, ggVal, this, ::apache::thrift::detail::union_field_ref_owner_vtable_for}; + } + Type getType() const { return static_cast(type_); } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + protected: + template + void destruct(T &val) { + (&val)->~T(); + } + + storage_type value_; + std::underlying_type_t type_; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< Value >; + friend void swap(Value& a, Value& b); +}; + +template +uint32_t Value::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}} // nebula::cpp2 +namespace nebula { namespace cpp2 { +class NList final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = NList; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + NList() {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + NList(apache::thrift::FragileConstructor, ::std::vector values__arg); + + NList(NList&&) = default; + + NList(const NList&) = default; + + + NList& operator=(NList&&) = default; + + NList& operator=(const NList&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::std::vector values; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool values; + } __isset = {}; + bool operator==(const NList& rhs) const; +#ifndef SWIG + friend bool operator!=(const NList& __x, const NList& __y) { + return !(__x == __y); + } +#endif + bool operator<(const NList& rhs) const; +#ifndef SWIG + friend bool operator>(const NList& __x, const NList& __y) { + return __y < __x; + } + friend bool operator<=(const NList& __x, const NList& __y) { + return !(__y < __x); + } + friend bool operator>=(const NList& __x, const NList& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::field_ref values_ref() const& { + return {this->values, __isset.values}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref values_ref() const&& { + return {std::move(this->values), __isset.values}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref values_ref() & { + return {this->values, __isset.values}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref values_ref() && { + return {std::move(this->values), __isset.values}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + const ::std::vector& get_values() const&; + ::std::vector get_values() &&; + + template > + ::std::vector& set_values(T_NList_values_struct_setter&& values_) { + values = std::forward(values_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.values = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return values; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< NList >; + friend void swap(NList& a, NList& b); +}; + +template +uint32_t NList::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}} // nebula::cpp2 +namespace nebula { namespace cpp2 { +class NMap final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = NMap; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + NMap() {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + NMap(apache::thrift::FragileConstructor, std::unordered_map<::std::string, nebula::Value> kvs__arg); + + NMap(NMap&&) = default; + + NMap(const NMap&) = default; + + + NMap& operator=(NMap&&) = default; + + NMap& operator=(const NMap&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + std::unordered_map<::std::string, nebula::Value> kvs; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool kvs; + } __isset = {}; + bool operator==(const NMap& rhs) const; +#ifndef SWIG + friend bool operator!=(const NMap& __x, const NMap& __y) { + return !(__x == __y); + } +#endif + bool operator<(const NMap& rhs) const; +#ifndef SWIG + friend bool operator>(const NMap& __x, const NMap& __y) { + return __y < __x; + } + friend bool operator<=(const NMap& __x, const NMap& __y) { + return !(__y < __x); + } + friend bool operator>=(const NMap& __x, const NMap& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::field_ref kvs_ref() const& { + return {this->kvs, __isset.kvs}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref kvs_ref() const&& { + return {std::move(this->kvs), __isset.kvs}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref kvs_ref() & { + return {this->kvs, __isset.kvs}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref kvs_ref() && { + return {std::move(this->kvs), __isset.kvs}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + const std::unordered_map<::std::string, nebula::Value>& get_kvs() const&; + std::unordered_map<::std::string, nebula::Value> get_kvs() &&; + + template > + std::unordered_map<::std::string, nebula::Value>& set_kvs(T_NMap_kvs_struct_setter&& kvs_) { + kvs = std::forward(kvs_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.kvs = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return kvs; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< NMap >; + friend void swap(NMap& a, NMap& b); +}; + +template +uint32_t NMap::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}} // nebula::cpp2 +namespace nebula { namespace cpp2 { +class NSet final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = NSet; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + NSet() {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + NSet(apache::thrift::FragileConstructor, std::unordered_set values__arg); + + NSet(NSet&&) = default; + + NSet(const NSet&) = default; + + + NSet& operator=(NSet&&) = default; + + NSet& operator=(const NSet&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + std::unordered_set values; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool values; + } __isset = {}; + bool operator==(const NSet& rhs) const; +#ifndef SWIG + friend bool operator!=(const NSet& __x, const NSet& __y) { + return !(__x == __y); + } +#endif + bool operator<(const NSet& rhs) const; +#ifndef SWIG + friend bool operator>(const NSet& __x, const NSet& __y) { + return __y < __x; + } + friend bool operator<=(const NSet& __x, const NSet& __y) { + return !(__y < __x); + } + friend bool operator>=(const NSet& __x, const NSet& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::field_ref values_ref() const& { + return {this->values, __isset.values}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref values_ref() const&& { + return {std::move(this->values), __isset.values}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref values_ref() & { + return {this->values, __isset.values}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref values_ref() && { + return {std::move(this->values), __isset.values}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + const std::unordered_set& get_values() const&; + std::unordered_set get_values() &&; + + template > + std::unordered_set& set_values(T_NSet_values_struct_setter&& values_) { + values = std::forward(values_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.values = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return values; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< NSet >; + friend void swap(NSet& a, NSet& b); +}; + +template +uint32_t NSet::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}} // nebula::cpp2 +namespace nebula { namespace cpp2 { +class Row final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = Row; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + Row() {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + Row(apache::thrift::FragileConstructor, ::std::vector values__arg); + + Row(Row&&) = default; + + Row(const Row&) = default; + + + Row& operator=(Row&&) = default; + + Row& operator=(const Row&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::std::vector values; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool values; + } __isset = {}; + bool operator==(const Row& rhs) const; +#ifndef SWIG + friend bool operator!=(const Row& __x, const Row& __y) { + return !(__x == __y); + } +#endif + bool operator<(const Row& rhs) const; +#ifndef SWIG + friend bool operator>(const Row& __x, const Row& __y) { + return __y < __x; + } + friend bool operator<=(const Row& __x, const Row& __y) { + return !(__y < __x); + } + friend bool operator>=(const Row& __x, const Row& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::field_ref values_ref() const& { + return {this->values, __isset.values}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref values_ref() const&& { + return {std::move(this->values), __isset.values}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref values_ref() & { + return {this->values, __isset.values}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref values_ref() && { + return {std::move(this->values), __isset.values}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + const ::std::vector& get_values() const&; + ::std::vector get_values() &&; + + template > + ::std::vector& set_values(T_Row_values_struct_setter&& values_) { + values = std::forward(values_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.values = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return values; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< Row >; + friend void swap(Row& a, Row& b); +}; + +template +uint32_t Row::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}} // nebula::cpp2 +namespace nebula { namespace cpp2 { +class DataSet final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = DataSet; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + DataSet() {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + DataSet(apache::thrift::FragileConstructor, ::std::vector<::std::string> column_names__arg, ::std::vector rows__arg); + + DataSet(DataSet&&) = default; + + DataSet(const DataSet&) = default; + + + DataSet& operator=(DataSet&&) = default; + + DataSet& operator=(const DataSet&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::std::vector<::std::string> column_names; + private: + ::std::vector rows; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool column_names; + bool rows; + } __isset = {}; + bool operator==(const DataSet& rhs) const; +#ifndef SWIG + friend bool operator!=(const DataSet& __x, const DataSet& __y) { + return !(__x == __y); + } +#endif + bool operator<(const DataSet& rhs) const; +#ifndef SWIG + friend bool operator>(const DataSet& __x, const DataSet& __y) { + return __y < __x; + } + friend bool operator<=(const DataSet& __x, const DataSet& __y) { + return !(__y < __x); + } + friend bool operator>=(const DataSet& __x, const DataSet& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::field_ref column_names_ref() const& { + return {this->column_names, __isset.column_names}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref column_names_ref() const&& { + return {std::move(this->column_names), __isset.column_names}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref column_names_ref() & { + return {this->column_names, __isset.column_names}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref column_names_ref() && { + return {std::move(this->column_names), __isset.column_names}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::field_ref rows_ref() const& { + return {this->rows, __isset.rows}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref rows_ref() const&& { + return {std::move(this->rows), __isset.rows}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref rows_ref() & { + return {this->rows, __isset.rows}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref rows_ref() && { + return {std::move(this->rows), __isset.rows}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + const ::std::vector<::std::string>& get_column_names() const&; + ::std::vector<::std::string> get_column_names() &&; + + template > + ::std::vector<::std::string>& set_column_names(T_DataSet_column_names_struct_setter&& column_names_) { + column_names = std::forward(column_names_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.column_names = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return column_names; + } + const ::std::vector& get_rows() const&; + ::std::vector get_rows() &&; + + template > + ::std::vector& set_rows(T_DataSet_rows_struct_setter&& rows_) { + rows = std::forward(rows_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.rows = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return rows; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< DataSet >; + friend void swap(DataSet& a, DataSet& b); +}; + +template +uint32_t DataSet::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}} // nebula::cpp2 +namespace nebula { namespace cpp2 { +class Geography final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = Geography; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + Geography() {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + Geography(apache::thrift::FragileConstructor, ::std::string wkb__arg); + + Geography(Geography&&) = default; + + Geography(const Geography&) = default; + + + Geography& operator=(Geography&&) = default; + + Geography& operator=(const Geography&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::std::string wkb; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool wkb; + } __isset = {}; + bool operator==(const Geography& rhs) const; +#ifndef SWIG + friend bool operator!=(const Geography& __x, const Geography& __y) { + return !(__x == __y); + } +#endif + bool operator<(const Geography& rhs) const; +#ifndef SWIG + friend bool operator>(const Geography& __x, const Geography& __y) { + return __y < __x; + } + friend bool operator<=(const Geography& __x, const Geography& __y) { + return !(__y < __x); + } + friend bool operator>=(const Geography& __x, const Geography& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref wkb_ref() const& { + return {this->wkb, __isset.wkb}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref wkb_ref() const&& { + return {std::move(this->wkb), __isset.wkb}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref wkb_ref() & { + return {this->wkb, __isset.wkb}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref wkb_ref() && { + return {std::move(this->wkb), __isset.wkb}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + const ::std::string& get_wkb() const& { + return wkb; + } + + ::std::string get_wkb() && { + return std::move(wkb); + } + + template + ::std::string& set_wkb(T_Geography_wkb_struct_setter&& wkb_) { + wkb = std::forward(wkb_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.wkb = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return wkb; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< Geography >; + friend void swap(Geography& a, Geography& b); +}; + +template +uint32_t Geography::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}} // nebula::cpp2 +namespace nebula { namespace cpp2 { +class Tag final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = Tag; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + Tag() {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + Tag(apache::thrift::FragileConstructor, ::std::string name__arg, std::unordered_map<::std::string, nebula::Value> props__arg); + + Tag(Tag&&) = default; + + Tag(const Tag&) = default; + + + Tag& operator=(Tag&&) = default; + + Tag& operator=(const Tag&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::std::string name; + private: + std::unordered_map<::std::string, nebula::Value> props; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool name; + bool props; + } __isset = {}; + bool operator==(const Tag& rhs) const; +#ifndef SWIG + friend bool operator!=(const Tag& __x, const Tag& __y) { + return !(__x == __y); + } +#endif + bool operator<(const Tag& rhs) const; +#ifndef SWIG + friend bool operator>(const Tag& __x, const Tag& __y) { + return __y < __x; + } + friend bool operator<=(const Tag& __x, const Tag& __y) { + return !(__y < __x); + } + friend bool operator>=(const Tag& __x, const Tag& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref name_ref() const& { + return {this->name, __isset.name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref name_ref() const&& { + return {std::move(this->name), __isset.name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref name_ref() & { + return {this->name, __isset.name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref name_ref() && { + return {std::move(this->name), __isset.name}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::field_ref props_ref() const& { + return {this->props, __isset.props}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref props_ref() const&& { + return {std::move(this->props), __isset.props}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref props_ref() & { + return {this->props, __isset.props}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref props_ref() && { + return {std::move(this->props), __isset.props}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + const ::std::string& get_name() const& { + return name; + } + + ::std::string get_name() && { + return std::move(name); + } + + template + ::std::string& set_name(T_Tag_name_struct_setter&& name_) { + name = std::forward(name_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.name = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return name; + } + const std::unordered_map<::std::string, nebula::Value>& get_props() const&; + std::unordered_map<::std::string, nebula::Value> get_props() &&; + + template > + std::unordered_map<::std::string, nebula::Value>& set_props(T_Tag_props_struct_setter&& props_) { + props = std::forward(props_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.props = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return props; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< Tag >; + friend void swap(Tag& a, Tag& b); +}; + +template +uint32_t Tag::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}} // nebula::cpp2 +namespace nebula { namespace cpp2 { +class Vertex final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = Vertex; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + Vertex() {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + Vertex(apache::thrift::FragileConstructor, nebula::Value vid__arg, ::std::vector tags__arg); + + Vertex(Vertex&&) = default; + + Vertex(const Vertex&) = default; + + + Vertex& operator=(Vertex&&) = default; + + Vertex& operator=(const Vertex&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + nebula::Value vid; + private: + ::std::vector tags; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool vid; + bool tags; + } __isset = {}; + bool operator==(const Vertex& rhs) const; +#ifndef SWIG + friend bool operator!=(const Vertex& __x, const Vertex& __y) { + return !(__x == __y); + } +#endif + bool operator<(const Vertex& rhs) const; +#ifndef SWIG + friend bool operator>(const Vertex& __x, const Vertex& __y) { + return __y < __x; + } + friend bool operator<=(const Vertex& __x, const Vertex& __y) { + return !(__y < __x); + } + friend bool operator>=(const Vertex& __x, const Vertex& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref vid_ref() const& { + return {this->vid, __isset.vid}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref vid_ref() const&& { + return {std::move(this->vid), __isset.vid}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref vid_ref() & { + return {this->vid, __isset.vid}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref vid_ref() && { + return {std::move(this->vid), __isset.vid}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::field_ref tags_ref() const& { + return {this->tags, __isset.tags}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref tags_ref() const&& { + return {std::move(this->tags), __isset.tags}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref tags_ref() & { + return {this->tags, __isset.tags}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref tags_ref() && { + return {std::move(this->tags), __isset.tags}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + const nebula::Value& get_vid() const&; + nebula::Value get_vid() &&; + + template + nebula::Value& set_vid(T_Vertex_vid_struct_setter&& vid_) { + vid = std::forward(vid_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.vid = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return vid; + } + const ::std::vector& get_tags() const&; + ::std::vector get_tags() &&; + + template > + ::std::vector& set_tags(T_Vertex_tags_struct_setter&& tags_) { + tags = std::forward(tags_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.tags = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return tags; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< Vertex >; + friend void swap(Vertex& a, Vertex& b); +}; + +template +uint32_t Vertex::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}} // nebula::cpp2 +namespace nebula { namespace cpp2 { +class Edge final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = Edge; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + + Edge(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + Edge(apache::thrift::FragileConstructor, nebula::Value src__arg, nebula::Value dst__arg, ::nebula::cpp2::EdgeType type__arg, ::std::string name__arg, ::nebula::cpp2::EdgeRanking ranking__arg, std::unordered_map<::std::string, nebula::Value> props__arg); + + Edge(Edge&&) = default; + + Edge(const Edge&) = default; + + + Edge& operator=(Edge&&) = default; + + Edge& operator=(const Edge&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + + ~Edge(); + + private: + nebula::Value src; + private: + nebula::Value dst; + private: + ::nebula::cpp2::EdgeType type; + private: + ::std::string name; + private: + ::nebula::cpp2::EdgeRanking ranking; + private: + std::unordered_map<::std::string, nebula::Value> props; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool src; + bool dst; + bool type; + bool name; + bool ranking; + bool props; + } __isset = {}; + bool operator==(const Edge& rhs) const; +#ifndef SWIG + friend bool operator!=(const Edge& __x, const Edge& __y) { + return !(__x == __y); + } +#endif + bool operator<(const Edge& rhs) const; +#ifndef SWIG + friend bool operator>(const Edge& __x, const Edge& __y) { + return __y < __x; + } + friend bool operator<=(const Edge& __x, const Edge& __y) { + return !(__y < __x); + } + friend bool operator>=(const Edge& __x, const Edge& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref src_ref() const& { + return {this->src, __isset.src}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref src_ref() const&& { + return {std::move(this->src), __isset.src}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref src_ref() & { + return {this->src, __isset.src}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref src_ref() && { + return {std::move(this->src), __isset.src}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref dst_ref() const& { + return {this->dst, __isset.dst}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref dst_ref() const&& { + return {std::move(this->dst), __isset.dst}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref dst_ref() & { + return {this->dst, __isset.dst}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref dst_ref() && { + return {std::move(this->dst), __isset.dst}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref type_ref() const& { + return {this->type, __isset.type}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref type_ref() const&& { + return {std::move(this->type), __isset.type}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref type_ref() & { + return {this->type, __isset.type}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref type_ref() && { + return {std::move(this->type), __isset.type}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref name_ref() const& { + return {this->name, __isset.name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref name_ref() const&& { + return {std::move(this->name), __isset.name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref name_ref() & { + return {this->name, __isset.name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref name_ref() && { + return {std::move(this->name), __isset.name}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref ranking_ref() const& { + return {this->ranking, __isset.ranking}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref ranking_ref() const&& { + return {std::move(this->ranking), __isset.ranking}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref ranking_ref() & { + return {this->ranking, __isset.ranking}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref ranking_ref() && { + return {std::move(this->ranking), __isset.ranking}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::field_ref props_ref() const& { + return {this->props, __isset.props}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref props_ref() const&& { + return {std::move(this->props), __isset.props}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref props_ref() & { + return {this->props, __isset.props}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref props_ref() && { + return {std::move(this->props), __isset.props}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + const nebula::Value& get_src() const&; + nebula::Value get_src() &&; + + template + nebula::Value& set_src(T_Edge_src_struct_setter&& src_) { + src = std::forward(src_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.src = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return src; + } + const nebula::Value& get_dst() const&; + nebula::Value get_dst() &&; + + template + nebula::Value& set_dst(T_Edge_dst_struct_setter&& dst_) { + dst = std::forward(dst_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.dst = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return dst; + } + + ::nebula::cpp2::EdgeType get_type() const { + return type; + } + + ::nebula::cpp2::EdgeType& set_type( ::nebula::cpp2::EdgeType type_) { + type = type_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.type = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return type; + } + + const ::std::string& get_name() const& { + return name; + } + + ::std::string get_name() && { + return std::move(name); + } + + template + ::std::string& set_name(T_Edge_name_struct_setter&& name_) { + name = std::forward(name_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.name = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return name; + } + + ::nebula::cpp2::EdgeRanking get_ranking() const { + return ranking; + } + + ::nebula::cpp2::EdgeRanking& set_ranking( ::nebula::cpp2::EdgeRanking ranking_) { + ranking = ranking_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.ranking = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return ranking; + } + const std::unordered_map<::std::string, nebula::Value>& get_props() const&; + std::unordered_map<::std::string, nebula::Value> get_props() &&; + + template > + std::unordered_map<::std::string, nebula::Value>& set_props(T_Edge_props_struct_setter&& props_) { + props = std::forward(props_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.props = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return props; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< Edge >; + friend void swap(Edge& a, Edge& b); +}; + +template +uint32_t Edge::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}} // nebula::cpp2 +namespace nebula { namespace cpp2 { +class Step final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = Step; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + + Step(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + Step(apache::thrift::FragileConstructor, nebula::Vertex dst__arg, ::nebula::cpp2::EdgeType type__arg, ::std::string name__arg, ::nebula::cpp2::EdgeRanking ranking__arg, std::unordered_map<::std::string, nebula::Value> props__arg); + + Step(Step&&) = default; + + Step(const Step&) = default; + + + Step& operator=(Step&&) = default; + + Step& operator=(const Step&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + + ~Step(); + + private: + nebula::Vertex dst; + private: + ::nebula::cpp2::EdgeType type; + private: + ::std::string name; + private: + ::nebula::cpp2::EdgeRanking ranking; + private: + std::unordered_map<::std::string, nebula::Value> props; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool dst; + bool type; + bool name; + bool ranking; + bool props; + } __isset = {}; + bool operator==(const Step& rhs) const; +#ifndef SWIG + friend bool operator!=(const Step& __x, const Step& __y) { + return !(__x == __y); + } +#endif + bool operator<(const Step& rhs) const; +#ifndef SWIG + friend bool operator>(const Step& __x, const Step& __y) { + return __y < __x; + } + friend bool operator<=(const Step& __x, const Step& __y) { + return !(__y < __x); + } + friend bool operator>=(const Step& __x, const Step& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref dst_ref() const& { + return {this->dst, __isset.dst}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref dst_ref() const&& { + return {std::move(this->dst), __isset.dst}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref dst_ref() & { + return {this->dst, __isset.dst}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref dst_ref() && { + return {std::move(this->dst), __isset.dst}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref type_ref() const& { + return {this->type, __isset.type}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref type_ref() const&& { + return {std::move(this->type), __isset.type}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref type_ref() & { + return {this->type, __isset.type}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref type_ref() && { + return {std::move(this->type), __isset.type}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref name_ref() const& { + return {this->name, __isset.name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref name_ref() const&& { + return {std::move(this->name), __isset.name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref name_ref() & { + return {this->name, __isset.name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref name_ref() && { + return {std::move(this->name), __isset.name}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref ranking_ref() const& { + return {this->ranking, __isset.ranking}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref ranking_ref() const&& { + return {std::move(this->ranking), __isset.ranking}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref ranking_ref() & { + return {this->ranking, __isset.ranking}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref ranking_ref() && { + return {std::move(this->ranking), __isset.ranking}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::field_ref props_ref() const& { + return {this->props, __isset.props}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref props_ref() const&& { + return {std::move(this->props), __isset.props}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref props_ref() & { + return {this->props, __isset.props}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref props_ref() && { + return {std::move(this->props), __isset.props}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + const nebula::Vertex& get_dst() const&; + nebula::Vertex get_dst() &&; + + template + nebula::Vertex& set_dst(T_Step_dst_struct_setter&& dst_) { + dst = std::forward(dst_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.dst = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return dst; + } + + ::nebula::cpp2::EdgeType get_type() const { + return type; + } + + ::nebula::cpp2::EdgeType& set_type( ::nebula::cpp2::EdgeType type_) { + type = type_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.type = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return type; + } + + const ::std::string& get_name() const& { + return name; + } + + ::std::string get_name() && { + return std::move(name); + } + + template + ::std::string& set_name(T_Step_name_struct_setter&& name_) { + name = std::forward(name_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.name = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return name; + } + + ::nebula::cpp2::EdgeRanking get_ranking() const { + return ranking; + } + + ::nebula::cpp2::EdgeRanking& set_ranking( ::nebula::cpp2::EdgeRanking ranking_) { + ranking = ranking_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.ranking = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return ranking; + } + const std::unordered_map<::std::string, nebula::Value>& get_props() const&; + std::unordered_map<::std::string, nebula::Value> get_props() &&; + + template > + std::unordered_map<::std::string, nebula::Value>& set_props(T_Step_props_struct_setter&& props_) { + props = std::forward(props_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.props = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return props; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< Step >; + friend void swap(Step& a, Step& b); +}; + +template +uint32_t Step::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}} // nebula::cpp2 +namespace nebula { namespace cpp2 { +class Path final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = Path; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + Path() {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + Path(apache::thrift::FragileConstructor, nebula::Vertex src__arg, ::std::vector steps__arg); + + Path(Path&&) = default; + + Path(const Path&) = default; + + + Path& operator=(Path&&) = default; + + Path& operator=(const Path&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + nebula::Vertex src; + private: + ::std::vector steps; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool src; + bool steps; + } __isset = {}; + bool operator==(const Path& rhs) const; +#ifndef SWIG + friend bool operator!=(const Path& __x, const Path& __y) { + return !(__x == __y); + } +#endif + bool operator<(const Path& rhs) const; +#ifndef SWIG + friend bool operator>(const Path& __x, const Path& __y) { + return __y < __x; + } + friend bool operator<=(const Path& __x, const Path& __y) { + return !(__y < __x); + } + friend bool operator>=(const Path& __x, const Path& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref src_ref() const& { + return {this->src, __isset.src}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref src_ref() const&& { + return {std::move(this->src), __isset.src}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref src_ref() & { + return {this->src, __isset.src}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref src_ref() && { + return {std::move(this->src), __isset.src}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::field_ref steps_ref() const& { + return {this->steps, __isset.steps}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref steps_ref() const&& { + return {std::move(this->steps), __isset.steps}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref steps_ref() & { + return {this->steps, __isset.steps}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref steps_ref() && { + return {std::move(this->steps), __isset.steps}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + const nebula::Vertex& get_src() const&; + nebula::Vertex get_src() &&; + + template + nebula::Vertex& set_src(T_Path_src_struct_setter&& src_) { + src = std::forward(src_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.src = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return src; + } + const ::std::vector& get_steps() const&; + ::std::vector get_steps() &&; + + template > + ::std::vector& set_steps(T_Path_steps_struct_setter&& steps_) { + steps = std::forward(steps_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.steps = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return steps; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< Path >; + friend void swap(Path& a, Path& b); +}; + +template +uint32_t Path::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}} // nebula::cpp2 +namespace nebula { namespace cpp2 { +class HostAddr final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = HostAddr; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + HostAddr() : + port(0) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + HostAddr(apache::thrift::FragileConstructor, ::std::string host__arg, ::nebula::cpp2::Port port__arg); + + HostAddr(HostAddr&&) = default; + + HostAddr(const HostAddr&) = default; + + + HostAddr& operator=(HostAddr&&) = default; + + HostAddr& operator=(const HostAddr&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::std::string host; + private: + ::nebula::cpp2::Port port; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool host; + bool port; + } __isset = {}; + bool operator==(const HostAddr& rhs) const; +#ifndef SWIG + friend bool operator!=(const HostAddr& __x, const HostAddr& __y) { + return !(__x == __y); + } +#endif + bool operator<(const HostAddr& rhs) const; +#ifndef SWIG + friend bool operator>(const HostAddr& __x, const HostAddr& __y) { + return __y < __x; + } + friend bool operator<=(const HostAddr& __x, const HostAddr& __y) { + return !(__y < __x); + } + friend bool operator>=(const HostAddr& __x, const HostAddr& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref host_ref() const& { + return {this->host, __isset.host}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref host_ref() const&& { + return {std::move(this->host), __isset.host}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref host_ref() & { + return {this->host, __isset.host}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref host_ref() && { + return {std::move(this->host), __isset.host}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref port_ref() const& { + return {this->port, __isset.port}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref port_ref() const&& { + return {std::move(this->port), __isset.port}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref port_ref() & { + return {this->port, __isset.port}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref port_ref() && { + return {std::move(this->port), __isset.port}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + const ::std::string& get_host() const& { + return host; + } + + ::std::string get_host() && { + return std::move(host); + } + + template + ::std::string& set_host(T_HostAddr_host_struct_setter&& host_) { + host = std::forward(host_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.host = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return host; + } + + ::nebula::cpp2::Port get_port() const { + return port; + } + + ::nebula::cpp2::Port& set_port( ::nebula::cpp2::Port port_) { + port = port_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.port = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return port; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< HostAddr >; + friend void swap(HostAddr& a, HostAddr& b); +}; + +template +uint32_t HostAddr::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}} // nebula::cpp2 +namespace nebula { namespace cpp2 { +class KeyValue final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = KeyValue; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + KeyValue() {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + KeyValue(apache::thrift::FragileConstructor, ::std::string key__arg, ::std::string value__arg); + + KeyValue(KeyValue&&) = default; + + KeyValue(const KeyValue&) = default; + + + KeyValue& operator=(KeyValue&&) = default; + + KeyValue& operator=(const KeyValue&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::std::string key; + private: + ::std::string value; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool key; + bool value; + } __isset = {}; + bool operator==(const KeyValue& rhs) const; +#ifndef SWIG + friend bool operator!=(const KeyValue& __x, const KeyValue& __y) { + return !(__x == __y); + } +#endif + bool operator<(const KeyValue& rhs) const; +#ifndef SWIG + friend bool operator>(const KeyValue& __x, const KeyValue& __y) { + return __y < __x; + } + friend bool operator<=(const KeyValue& __x, const KeyValue& __y) { + return !(__y < __x); + } + friend bool operator>=(const KeyValue& __x, const KeyValue& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref key_ref() const& { + return {this->key, __isset.key}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref key_ref() const&& { + return {std::move(this->key), __isset.key}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref key_ref() & { + return {this->key, __isset.key}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref key_ref() && { + return {std::move(this->key), __isset.key}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref value_ref() const& { + return {this->value, __isset.value}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref value_ref() const&& { + return {std::move(this->value), __isset.value}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref value_ref() & { + return {this->value, __isset.value}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref value_ref() && { + return {std::move(this->value), __isset.value}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + const ::std::string& get_key() const& { + return key; + } + + ::std::string get_key() && { + return std::move(key); + } + + template + ::std::string& set_key(T_KeyValue_key_struct_setter&& key_) { + key = std::forward(key_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.key = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return key; + } + + const ::std::string& get_value() const& { + return value; + } + + ::std::string get_value() && { + return std::move(value); + } + + template + ::std::string& set_value(T_KeyValue_value_struct_setter&& value_) { + value = std::forward(value_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.value = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return value; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< KeyValue >; + friend void swap(KeyValue& a, KeyValue& b); +}; + +template +uint32_t KeyValue::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}} // nebula::cpp2 +namespace nebula { namespace cpp2 { +class LogInfo final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = LogInfo; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + LogInfo() : + log_id(0), + term_id(0) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + LogInfo(apache::thrift::FragileConstructor, ::nebula::cpp2::LogID log_id__arg, ::nebula::cpp2::TermID term_id__arg); + + LogInfo(LogInfo&&) = default; + + LogInfo(const LogInfo&) = default; + + + LogInfo& operator=(LogInfo&&) = default; + + LogInfo& operator=(const LogInfo&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::LogID log_id; + private: + ::nebula::cpp2::TermID term_id; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool log_id; + bool term_id; + } __isset = {}; + bool operator==(const LogInfo& rhs) const; +#ifndef SWIG + friend bool operator!=(const LogInfo& __x, const LogInfo& __y) { + return !(__x == __y); + } +#endif + bool operator<(const LogInfo& rhs) const; +#ifndef SWIG + friend bool operator>(const LogInfo& __x, const LogInfo& __y) { + return __y < __x; + } + friend bool operator<=(const LogInfo& __x, const LogInfo& __y) { + return !(__y < __x); + } + friend bool operator>=(const LogInfo& __x, const LogInfo& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref log_id_ref() const& { + return {this->log_id, __isset.log_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref log_id_ref() const&& { + return {std::move(this->log_id), __isset.log_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref log_id_ref() & { + return {this->log_id, __isset.log_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref log_id_ref() && { + return {std::move(this->log_id), __isset.log_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref term_id_ref() const& { + return {this->term_id, __isset.term_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref term_id_ref() const&& { + return {std::move(this->term_id), __isset.term_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref term_id_ref() & { + return {this->term_id, __isset.term_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref term_id_ref() && { + return {std::move(this->term_id), __isset.term_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::LogID get_log_id() const { + return log_id; + } + + ::nebula::cpp2::LogID& set_log_id( ::nebula::cpp2::LogID log_id_) { + log_id = log_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.log_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return log_id; + } + + ::nebula::cpp2::TermID get_term_id() const { + return term_id; + } + + ::nebula::cpp2::TermID& set_term_id( ::nebula::cpp2::TermID term_id_) { + term_id = term_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.term_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return term_id; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< LogInfo >; + friend void swap(LogInfo& a, LogInfo& b); +}; + +template +uint32_t LogInfo::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}} // nebula::cpp2 +namespace nebula { namespace cpp2 { +class DirInfo final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = DirInfo; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + DirInfo() {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + DirInfo(apache::thrift::FragileConstructor, ::std::string root__arg, ::std::vector<::std::string> data__arg); + + DirInfo(DirInfo&&) = default; + + DirInfo(const DirInfo&) = default; + + + DirInfo& operator=(DirInfo&&) = default; + + DirInfo& operator=(const DirInfo&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::std::string root; + private: + ::std::vector<::std::string> data; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool root; + bool data; + } __isset = {}; + bool operator==(const DirInfo& rhs) const; +#ifndef SWIG + friend bool operator!=(const DirInfo& __x, const DirInfo& __y) { + return !(__x == __y); + } +#endif + bool operator<(const DirInfo& rhs) const; +#ifndef SWIG + friend bool operator>(const DirInfo& __x, const DirInfo& __y) { + return __y < __x; + } + friend bool operator<=(const DirInfo& __x, const DirInfo& __y) { + return !(__y < __x); + } + friend bool operator>=(const DirInfo& __x, const DirInfo& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref root_ref() const& { + return {this->root, __isset.root}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref root_ref() const&& { + return {std::move(this->root), __isset.root}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref root_ref() & { + return {this->root, __isset.root}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref root_ref() && { + return {std::move(this->root), __isset.root}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::field_ref data_ref() const& { + return {this->data, __isset.data}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref data_ref() const&& { + return {std::move(this->data), __isset.data}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref data_ref() & { + return {this->data, __isset.data}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref data_ref() && { + return {std::move(this->data), __isset.data}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + const ::std::string& get_root() const& { + return root; + } + + ::std::string get_root() && { + return std::move(root); + } + + template + ::std::string& set_root(T_DirInfo_root_struct_setter&& root_) { + root = std::forward(root_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.root = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return root; + } + const ::std::vector<::std::string>& get_data() const&; + ::std::vector<::std::string> get_data() &&; + + template > + ::std::vector<::std::string>& set_data(T_DirInfo_data_struct_setter&& data_) { + data = std::forward(data_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.data = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return data; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< DirInfo >; + friend void swap(DirInfo& a, DirInfo& b); +}; + +template +uint32_t DirInfo::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}} // nebula::cpp2 +namespace nebula { namespace cpp2 { +class NodeInfo final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = NodeInfo; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + NodeInfo() {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + NodeInfo(apache::thrift::FragileConstructor, nebula::HostAddr host__arg, ::nebula::cpp2::DirInfo dir__arg); + + NodeInfo(NodeInfo&&) = default; + + NodeInfo(const NodeInfo&) = default; + + + NodeInfo& operator=(NodeInfo&&) = default; + + NodeInfo& operator=(const NodeInfo&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + nebula::HostAddr host; + private: + ::nebula::cpp2::DirInfo dir; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool host; + bool dir; + } __isset = {}; + bool operator==(const NodeInfo& rhs) const; +#ifndef SWIG + friend bool operator!=(const NodeInfo& __x, const NodeInfo& __y) { + return !(__x == __y); + } +#endif + bool operator<(const NodeInfo& rhs) const; +#ifndef SWIG + friend bool operator>(const NodeInfo& __x, const NodeInfo& __y) { + return __y < __x; + } + friend bool operator<=(const NodeInfo& __x, const NodeInfo& __y) { + return !(__y < __x); + } + friend bool operator>=(const NodeInfo& __x, const NodeInfo& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref host_ref() const& { + return {this->host, __isset.host}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref host_ref() const&& { + return {std::move(this->host), __isset.host}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref host_ref() & { + return {this->host, __isset.host}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref host_ref() && { + return {std::move(this->host), __isset.host}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref dir_ref() const& { + return {this->dir, __isset.dir}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref dir_ref() const&& { + return {std::move(this->dir), __isset.dir}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref dir_ref() & { + return {this->dir, __isset.dir}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref dir_ref() && { + return {std::move(this->dir), __isset.dir}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + const nebula::HostAddr& get_host() const&; + nebula::HostAddr get_host() &&; + + template + nebula::HostAddr& set_host(T_NodeInfo_host_struct_setter&& host_) { + host = std::forward(host_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.host = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return host; + } + const ::nebula::cpp2::DirInfo& get_dir() const&; + ::nebula::cpp2::DirInfo get_dir() &&; + + template + ::nebula::cpp2::DirInfo& set_dir(T_NodeInfo_dir_struct_setter&& dir_) { + dir = std::forward(dir_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.dir = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return dir; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< NodeInfo >; + friend void swap(NodeInfo& a, NodeInfo& b); +}; + +template +uint32_t NodeInfo::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}} // nebula::cpp2 +namespace nebula { namespace cpp2 { +class PartitionBackupInfo final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = PartitionBackupInfo; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + PartitionBackupInfo() {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + PartitionBackupInfo(apache::thrift::FragileConstructor, std::unordered_map< ::nebula::cpp2::PartitionID, ::nebula::cpp2::LogInfo> info__arg); + + PartitionBackupInfo(PartitionBackupInfo&&) = default; + + PartitionBackupInfo(const PartitionBackupInfo&) = default; + + + PartitionBackupInfo& operator=(PartitionBackupInfo&&) = default; + + PartitionBackupInfo& operator=(const PartitionBackupInfo&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + std::unordered_map< ::nebula::cpp2::PartitionID, ::nebula::cpp2::LogInfo> info; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool info; + } __isset = {}; + bool operator==(const PartitionBackupInfo& rhs) const; +#ifndef SWIG + friend bool operator!=(const PartitionBackupInfo& __x, const PartitionBackupInfo& __y) { + return !(__x == __y); + } +#endif + bool operator<(const PartitionBackupInfo& rhs) const; +#ifndef SWIG + friend bool operator>(const PartitionBackupInfo& __x, const PartitionBackupInfo& __y) { + return __y < __x; + } + friend bool operator<=(const PartitionBackupInfo& __x, const PartitionBackupInfo& __y) { + return !(__y < __x); + } + friend bool operator>=(const PartitionBackupInfo& __x, const PartitionBackupInfo& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::field_ref info_ref() const& { + return {this->info, __isset.info}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref info_ref() const&& { + return {std::move(this->info), __isset.info}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref info_ref() & { + return {this->info, __isset.info}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref info_ref() && { + return {std::move(this->info), __isset.info}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + const std::unordered_map< ::nebula::cpp2::PartitionID, ::nebula::cpp2::LogInfo>& get_info() const&; + std::unordered_map< ::nebula::cpp2::PartitionID, ::nebula::cpp2::LogInfo> get_info() &&; + + template > + std::unordered_map< ::nebula::cpp2::PartitionID, ::nebula::cpp2::LogInfo>& set_info(T_PartitionBackupInfo_info_struct_setter&& info_) { + info = std::forward(info_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.info = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return info; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< PartitionBackupInfo >; + friend void swap(PartitionBackupInfo& a, PartitionBackupInfo& b); +}; + +template +uint32_t PartitionBackupInfo::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}} // nebula::cpp2 +namespace nebula { namespace cpp2 { +class CheckpointInfo final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = CheckpointInfo; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + CheckpointInfo() {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + CheckpointInfo(apache::thrift::FragileConstructor, ::nebula::cpp2::PartitionBackupInfo partition_info__arg, ::std::string path__arg); + + CheckpointInfo(CheckpointInfo&&) = default; + + CheckpointInfo(const CheckpointInfo&) = default; + + + CheckpointInfo& operator=(CheckpointInfo&&) = default; + + CheckpointInfo& operator=(const CheckpointInfo&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::PartitionBackupInfo partition_info; + private: + ::std::string path; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool partition_info; + bool path; + } __isset = {}; + bool operator==(const CheckpointInfo& rhs) const; +#ifndef SWIG + friend bool operator!=(const CheckpointInfo& __x, const CheckpointInfo& __y) { + return !(__x == __y); + } +#endif + bool operator<(const CheckpointInfo& rhs) const; +#ifndef SWIG + friend bool operator>(const CheckpointInfo& __x, const CheckpointInfo& __y) { + return __y < __x; + } + friend bool operator<=(const CheckpointInfo& __x, const CheckpointInfo& __y) { + return !(__y < __x); + } + friend bool operator>=(const CheckpointInfo& __x, const CheckpointInfo& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref partition_info_ref() const& { + return {this->partition_info, __isset.partition_info}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref partition_info_ref() const&& { + return {std::move(this->partition_info), __isset.partition_info}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref partition_info_ref() & { + return {this->partition_info, __isset.partition_info}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref partition_info_ref() && { + return {std::move(this->partition_info), __isset.partition_info}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref path_ref() const& { + return {this->path, __isset.path}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref path_ref() const&& { + return {std::move(this->path), __isset.path}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref path_ref() & { + return {this->path, __isset.path}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref path_ref() && { + return {std::move(this->path), __isset.path}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + const ::nebula::cpp2::PartitionBackupInfo& get_partition_info() const&; + ::nebula::cpp2::PartitionBackupInfo get_partition_info() &&; + + template + ::nebula::cpp2::PartitionBackupInfo& set_partition_info(T_CheckpointInfo_partition_info_struct_setter&& partition_info_) { + partition_info = std::forward(partition_info_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.partition_info = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return partition_info; + } + + const ::std::string& get_path() const& { + return path; + } + + ::std::string get_path() && { + return std::move(path); + } + + template + ::std::string& set_path(T_CheckpointInfo_path_struct_setter&& path_) { + path = std::forward(path_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.path = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return path; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< CheckpointInfo >; + friend void swap(CheckpointInfo& a, CheckpointInfo& b); +}; + +template +uint32_t CheckpointInfo::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}} // nebula::cpp2 + +namespace apache { namespace thrift { + +template <> struct TEnumDataStorage<::nebula::cpp2::SchemaID::Type>; + +template <> struct TEnumTraits<::nebula::cpp2::SchemaID::Type> { + using type = ::nebula::cpp2::SchemaID::Type; + + static constexpr std::size_t const size = 2; + static folly::Range const values; + static folly::Range const names; + + static char const* findName(type value); + static bool findValue(char const* name, type* out); + +}; + +template <> struct TEnumDataStorage<::nebula::cpp2::Value::Type>; + +template <> struct TEnumTraits<::nebula::cpp2::Value::Type> { + using type = ::nebula::cpp2::Value::Type; + + static constexpr std::size_t const size = 16; + static folly::Range const values; + static folly::Range const names; + + static char const* findName(type value); + static bool findValue(char const* name, type* out); + +}; +}} // apache::thrift diff --git a/src/interface/gen-cpp2/common_types.tcc b/src/interface/gen-cpp2/common_types.tcc new file mode 100644 index 00000000..d04818c8 --- /dev/null +++ b/src/interface/gen-cpp2/common_types.tcc @@ -0,0 +1,4326 @@ +/** + * Autogenerated by Thrift for common.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#pragma once + +#include "common_types.h" + +#include + +namespace nebula { namespace cpp2 { + +}} // nebula::cpp2 +namespace std { + +} // std + +namespace nebula { namespace cpp2 { + +}} // nebula::cpp2 +namespace std { + +} // std + + +namespace apache { +namespace thrift { +namespace detail { + +template <> +struct TccStructTraits<::nebula::cpp2::SchemaID> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::cpp2::Date> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::cpp2::Time> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::cpp2::DateTime> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::cpp2::Value> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::cpp2::NList> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::cpp2::NMap> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::cpp2::NSet> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::cpp2::Row> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::cpp2::DataSet> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::cpp2::Geography> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::cpp2::Tag> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::cpp2::Vertex> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::cpp2::Edge> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::cpp2::Step> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::cpp2::Path> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::cpp2::HostAddr> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::cpp2::KeyValue> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::cpp2::LogInfo> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::cpp2::DirInfo> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::cpp2::NodeInfo> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::cpp2::PartitionBackupInfo> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::cpp2::CheckpointInfo> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace cpp2 { + +template +void SchemaID::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + _readState.fieldId = 0; + + _readState.readStructBegin(iprot); + + _readState.readFieldBegin(iprot); + if (_readState.atStop()) { + this->__clear(); + } else { + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + switch (_readState.fieldId) { + case 1: + { + if (_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32)) { + this->set_tag_id(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::TagID>::readWithContext(*iprot, this->mutable_tag_id(), _readState); + } else { + _readState.skip(iprot); + } + break; + } + case 2: + { + if (_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32)) { + this->set_edge_type(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::EdgeType>::readWithContext(*iprot, this->mutable_edge_type(), _readState); + } else { + _readState.skip(iprot); + } + break; + } + default: + { + _readState.skip(iprot); + break; + } + } + _readState.readFieldEnd(iprot); + _readState.readFieldBegin(iprot); + if (UNLIKELY(!_readState.atStop())) { + using apache::thrift::protocol::TProtocolException; + TProtocolException::throwUnionMissingStop(); + } + } + _readState.readStructEnd(iprot); +} +template +uint32_t SchemaID::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("SchemaID"); + switch(this->getType()) { + case SchemaID::Type::tag_id: + { + xfer += prot_->serializedFieldSize("tag_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::TagID>::serializedSize(*prot_, this->get_tag_id()); + break; + } + case SchemaID::Type::edge_type: + { + xfer += prot_->serializedFieldSize("edge_type", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::EdgeType>::serializedSize(*prot_, this->get_edge_type()); + break; + } + case SchemaID::Type::__EMPTY__:; + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t SchemaID::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("SchemaID"); + switch(this->getType()) { + case SchemaID::Type::tag_id: + { + xfer += prot_->serializedFieldSize("tag_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::TagID>::serializedSize(*prot_, this->get_tag_id()); + break; + } + case SchemaID::Type::edge_type: + { + xfer += prot_->serializedFieldSize("edge_type", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::EdgeType>::serializedSize(*prot_, this->get_edge_type()); + break; + } + case SchemaID::Type::__EMPTY__:; + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t SchemaID::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("SchemaID"); + switch(this->getType()) { + case SchemaID::Type::tag_id: + { + xfer += prot_->writeFieldBegin("tag_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::TagID>::write(*prot_, this->get_tag_id()); + xfer += prot_->writeFieldEnd(); + break; + } + case SchemaID::Type::edge_type: + { + xfer += prot_->writeFieldBegin("edge_type", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::EdgeType>::write(*prot_, this->get_edge_type()); + xfer += prot_->writeFieldEnd(); + break; + } + case SchemaID::Type::__EMPTY__:; + } + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void SchemaID::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t SchemaID::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t SchemaID::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t SchemaID::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void SchemaID::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t SchemaID::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t SchemaID::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t SchemaID::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}} // nebula::cpp2 +namespace nebula { namespace cpp2 { + +template +void Date::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I16))) { + goto _loop; + } +_readField_year: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int16_t>::readWithContext(*iprot, this->year, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.year = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_BYTE))) { + goto _loop; + } +_readField_month: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int8_t>::readWithContext(*iprot, this->month, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.month = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_BYTE))) { + goto _loop; + } +_readField_day: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int8_t>::readWithContext(*iprot, this->day, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.day = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I16))) { + goto _readField_year; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_BYTE))) { + goto _readField_month; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_BYTE))) { + goto _readField_day; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t Date::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("Date"); + xfer += prot_->serializedFieldSize("year", apache::thrift::protocol::T_I16, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int16_t>::serializedSize(*prot_, this->year); + xfer += prot_->serializedFieldSize("month", apache::thrift::protocol::T_BYTE, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int8_t>::serializedSize(*prot_, this->month); + xfer += prot_->serializedFieldSize("day", apache::thrift::protocol::T_BYTE, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int8_t>::serializedSize(*prot_, this->day); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t Date::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("Date"); + xfer += prot_->serializedFieldSize("year", apache::thrift::protocol::T_I16, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int16_t>::serializedSize(*prot_, this->year); + xfer += prot_->serializedFieldSize("month", apache::thrift::protocol::T_BYTE, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int8_t>::serializedSize(*prot_, this->month); + xfer += prot_->serializedFieldSize("day", apache::thrift::protocol::T_BYTE, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int8_t>::serializedSize(*prot_, this->day); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t Date::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("Date"); + xfer += prot_->writeFieldBegin("year", apache::thrift::protocol::T_I16, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int16_t>::write(*prot_, this->year); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("month", apache::thrift::protocol::T_BYTE, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int8_t>::write(*prot_, this->month); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("day", apache::thrift::protocol::T_BYTE, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int8_t>::write(*prot_, this->day); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void Date::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t Date::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t Date::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t Date::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void Date::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t Date::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t Date::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t Date::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}} // nebula::cpp2 +namespace nebula { namespace cpp2 { + +template +void Time::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_BYTE))) { + goto _loop; + } +_readField_hour: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int8_t>::readWithContext(*iprot, this->hour, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.hour = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_BYTE))) { + goto _loop; + } +_readField_minute: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int8_t>::readWithContext(*iprot, this->minute, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.minute = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_BYTE))) { + goto _loop; + } +_readField_sec: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int8_t>::readWithContext(*iprot, this->sec, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.sec = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 4, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_microsec: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::readWithContext(*iprot, this->microsec, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.microsec = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 4, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_BYTE))) { + goto _readField_hour; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_BYTE))) { + goto _readField_minute; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_BYTE))) { + goto _readField_sec; + } else { + goto _skip; + } + } + case 4: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_microsec; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t Time::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("Time"); + xfer += prot_->serializedFieldSize("hour", apache::thrift::protocol::T_BYTE, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int8_t>::serializedSize(*prot_, this->hour); + xfer += prot_->serializedFieldSize("minute", apache::thrift::protocol::T_BYTE, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int8_t>::serializedSize(*prot_, this->minute); + xfer += prot_->serializedFieldSize("sec", apache::thrift::protocol::T_BYTE, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int8_t>::serializedSize(*prot_, this->sec); + xfer += prot_->serializedFieldSize("microsec", apache::thrift::protocol::T_I32, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::serializedSize(*prot_, this->microsec); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t Time::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("Time"); + xfer += prot_->serializedFieldSize("hour", apache::thrift::protocol::T_BYTE, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int8_t>::serializedSize(*prot_, this->hour); + xfer += prot_->serializedFieldSize("minute", apache::thrift::protocol::T_BYTE, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int8_t>::serializedSize(*prot_, this->minute); + xfer += prot_->serializedFieldSize("sec", apache::thrift::protocol::T_BYTE, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int8_t>::serializedSize(*prot_, this->sec); + xfer += prot_->serializedFieldSize("microsec", apache::thrift::protocol::T_I32, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::serializedSize(*prot_, this->microsec); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t Time::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("Time"); + xfer += prot_->writeFieldBegin("hour", apache::thrift::protocol::T_BYTE, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int8_t>::write(*prot_, this->hour); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("minute", apache::thrift::protocol::T_BYTE, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int8_t>::write(*prot_, this->minute); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("sec", apache::thrift::protocol::T_BYTE, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int8_t>::write(*prot_, this->sec); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("microsec", apache::thrift::protocol::T_I32, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::write(*prot_, this->microsec); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void Time::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t Time::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t Time::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t Time::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void Time::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t Time::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t Time::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t Time::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}} // nebula::cpp2 +namespace nebula { namespace cpp2 { + +template +void DateTime::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I16))) { + goto _loop; + } +_readField_year: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int16_t>::readWithContext(*iprot, this->year, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.year = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_BYTE))) { + goto _loop; + } +_readField_month: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int8_t>::readWithContext(*iprot, this->month, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.month = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_BYTE))) { + goto _loop; + } +_readField_day: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int8_t>::readWithContext(*iprot, this->day, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.day = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 4, + apache::thrift::protocol::T_BYTE))) { + goto _loop; + } +_readField_hour: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int8_t>::readWithContext(*iprot, this->hour, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.hour = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 4, + 5, + apache::thrift::protocol::T_BYTE))) { + goto _loop; + } +_readField_minute: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int8_t>::readWithContext(*iprot, this->minute, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.minute = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 5, + 6, + apache::thrift::protocol::T_BYTE))) { + goto _loop; + } +_readField_sec: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int8_t>::readWithContext(*iprot, this->sec, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.sec = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 6, + 7, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_microsec: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::readWithContext(*iprot, this->microsec, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.microsec = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 7, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I16))) { + goto _readField_year; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_BYTE))) { + goto _readField_month; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_BYTE))) { + goto _readField_day; + } else { + goto _skip; + } + } + case 4: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_BYTE))) { + goto _readField_hour; + } else { + goto _skip; + } + } + case 5: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_BYTE))) { + goto _readField_minute; + } else { + goto _skip; + } + } + case 6: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_BYTE))) { + goto _readField_sec; + } else { + goto _skip; + } + } + case 7: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_microsec; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t DateTime::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("DateTime"); + xfer += prot_->serializedFieldSize("year", apache::thrift::protocol::T_I16, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int16_t>::serializedSize(*prot_, this->year); + xfer += prot_->serializedFieldSize("month", apache::thrift::protocol::T_BYTE, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int8_t>::serializedSize(*prot_, this->month); + xfer += prot_->serializedFieldSize("day", apache::thrift::protocol::T_BYTE, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int8_t>::serializedSize(*prot_, this->day); + xfer += prot_->serializedFieldSize("hour", apache::thrift::protocol::T_BYTE, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int8_t>::serializedSize(*prot_, this->hour); + xfer += prot_->serializedFieldSize("minute", apache::thrift::protocol::T_BYTE, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int8_t>::serializedSize(*prot_, this->minute); + xfer += prot_->serializedFieldSize("sec", apache::thrift::protocol::T_BYTE, 6); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int8_t>::serializedSize(*prot_, this->sec); + xfer += prot_->serializedFieldSize("microsec", apache::thrift::protocol::T_I32, 7); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::serializedSize(*prot_, this->microsec); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t DateTime::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("DateTime"); + xfer += prot_->serializedFieldSize("year", apache::thrift::protocol::T_I16, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int16_t>::serializedSize(*prot_, this->year); + xfer += prot_->serializedFieldSize("month", apache::thrift::protocol::T_BYTE, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int8_t>::serializedSize(*prot_, this->month); + xfer += prot_->serializedFieldSize("day", apache::thrift::protocol::T_BYTE, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int8_t>::serializedSize(*prot_, this->day); + xfer += prot_->serializedFieldSize("hour", apache::thrift::protocol::T_BYTE, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int8_t>::serializedSize(*prot_, this->hour); + xfer += prot_->serializedFieldSize("minute", apache::thrift::protocol::T_BYTE, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int8_t>::serializedSize(*prot_, this->minute); + xfer += prot_->serializedFieldSize("sec", apache::thrift::protocol::T_BYTE, 6); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int8_t>::serializedSize(*prot_, this->sec); + xfer += prot_->serializedFieldSize("microsec", apache::thrift::protocol::T_I32, 7); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::serializedSize(*prot_, this->microsec); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t DateTime::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("DateTime"); + xfer += prot_->writeFieldBegin("year", apache::thrift::protocol::T_I16, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int16_t>::write(*prot_, this->year); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("month", apache::thrift::protocol::T_BYTE, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int8_t>::write(*prot_, this->month); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("day", apache::thrift::protocol::T_BYTE, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int8_t>::write(*prot_, this->day); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("hour", apache::thrift::protocol::T_BYTE, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int8_t>::write(*prot_, this->hour); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("minute", apache::thrift::protocol::T_BYTE, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int8_t>::write(*prot_, this->minute); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("sec", apache::thrift::protocol::T_BYTE, 6); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int8_t>::write(*prot_, this->sec); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("microsec", apache::thrift::protocol::T_I32, 7); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::write(*prot_, this->microsec); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void DateTime::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t DateTime::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t DateTime::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t DateTime::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void DateTime::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t DateTime::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t DateTime::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t DateTime::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}} // nebula::cpp2 +namespace nebula { namespace cpp2 { + +template +void Value::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + _readState.fieldId = 0; + + _readState.readStructBegin(iprot); + + _readState.readFieldBegin(iprot); + if (_readState.atStop()) { + this->__clear(); + } else { + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + switch (_readState.fieldId) { + case 1: + { + if (_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32)) { + this->set_nVal(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, nebula::NullType>::readWithContext(*iprot, this->mutable_nVal(), _readState); + } else { + _readState.skip(iprot); + } + break; + } + case 2: + { + if (_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_BOOL)) { + this->set_bVal(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::readWithContext(*iprot, this->mutable_bVal(), _readState); + } else { + _readState.skip(iprot); + } + break; + } + case 3: + { + if (_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I64)) { + this->set_iVal(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::readWithContext(*iprot, this->mutable_iVal(), _readState); + } else { + _readState.skip(iprot); + } + break; + } + case 4: + { + if (_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_DOUBLE)) { + this->set_fVal(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::floating_point, double>::readWithContext(*iprot, this->mutable_fVal(), _readState); + } else { + _readState.skip(iprot); + } + break; + } + case 5: + { + if (_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING)) { + this->set_sVal(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->mutable_sVal(), _readState); + } else { + _readState.skip(iprot); + } + break; + } + case 6: + { + if (_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT)) { + this->set_dVal(); + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::Date>::readWithContext(*iprot, this->mutable_dVal(), _readState); + _readState.afterSubobject(iprot); + } else { + _readState.skip(iprot); + } + break; + } + case 7: + { + if (_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT)) { + this->set_tVal(); + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::Time>::readWithContext(*iprot, this->mutable_tVal(), _readState); + _readState.afterSubobject(iprot); + } else { + _readState.skip(iprot); + } + break; + } + case 8: + { + if (_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT)) { + this->set_dtVal(); + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::DateTime>::readWithContext(*iprot, this->mutable_dtVal(), _readState); + _readState.afterSubobject(iprot); + } else { + _readState.skip(iprot); + } + break; + } + case 9: + { + if (_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT)) { + this->set_vVal(); + _readState.beforeSubobject(iprot); + std::unique_ptr ptr = std::make_unique(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::Vertex>::readWithContext(*iprot, *ptr, _readState); + this->mutable_vVal() = std::move(ptr); + _readState.afterSubobject(iprot); + } else { + _readState.skip(iprot); + } + break; + } + case 10: + { + if (_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT)) { + this->set_eVal(); + _readState.beforeSubobject(iprot); + std::unique_ptr ptr = std::make_unique(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::Edge>::readWithContext(*iprot, *ptr, _readState); + this->mutable_eVal() = std::move(ptr); + _readState.afterSubobject(iprot); + } else { + _readState.skip(iprot); + } + break; + } + case 11: + { + if (_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT)) { + this->set_pVal(); + _readState.beforeSubobject(iprot); + std::unique_ptr ptr = std::make_unique(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::Path>::readWithContext(*iprot, *ptr, _readState); + this->mutable_pVal() = std::move(ptr); + _readState.afterSubobject(iprot); + } else { + _readState.skip(iprot); + } + break; + } + case 12: + { + if (_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT)) { + this->set_lVal(); + _readState.beforeSubobject(iprot); + std::unique_ptr ptr = std::make_unique(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::List>::readWithContext(*iprot, *ptr, _readState); + this->mutable_lVal() = std::move(ptr); + _readState.afterSubobject(iprot); + } else { + _readState.skip(iprot); + } + break; + } + case 13: + { + if (_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT)) { + this->set_mVal(); + _readState.beforeSubobject(iprot); + std::unique_ptr ptr = std::make_unique(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::Map>::readWithContext(*iprot, *ptr, _readState); + this->mutable_mVal() = std::move(ptr); + _readState.afterSubobject(iprot); + } else { + _readState.skip(iprot); + } + break; + } + case 14: + { + if (_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT)) { + this->set_uVal(); + _readState.beforeSubobject(iprot); + std::unique_ptr ptr = std::make_unique(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::Set>::readWithContext(*iprot, *ptr, _readState); + this->mutable_uVal() = std::move(ptr); + _readState.afterSubobject(iprot); + } else { + _readState.skip(iprot); + } + break; + } + case 15: + { + if (_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT)) { + this->set_gVal(); + _readState.beforeSubobject(iprot); + std::unique_ptr ptr = std::make_unique(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::DataSet>::readWithContext(*iprot, *ptr, _readState); + this->mutable_gVal() = std::move(ptr); + _readState.afterSubobject(iprot); + } else { + _readState.skip(iprot); + } + break; + } + case 16: + { + if (_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT)) { + this->set_ggVal(); + _readState.beforeSubobject(iprot); + std::unique_ptr ptr = std::make_unique(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::Geography>::readWithContext(*iprot, *ptr, _readState); + this->mutable_ggVal() = std::move(ptr); + _readState.afterSubobject(iprot); + } else { + _readState.skip(iprot); + } + break; + } + default: + { + _readState.skip(iprot); + break; + } + } + _readState.readFieldEnd(iprot); + _readState.readFieldBegin(iprot); + if (UNLIKELY(!_readState.atStop())) { + using apache::thrift::protocol::TProtocolException; + TProtocolException::throwUnionMissingStop(); + } + } + _readState.readStructEnd(iprot); +} +template +uint32_t Value::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("Value"); + switch(this->getType()) { + case Value::Type::nVal: + { + xfer += prot_->serializedFieldSize("nVal", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, nebula::NullType>::serializedSize(*prot_, this->get_nVal()); + break; + } + case Value::Type::bVal: + { + xfer += prot_->serializedFieldSize("bVal", apache::thrift::protocol::T_BOOL, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::serializedSize(*prot_, this->get_bVal()); + break; + } + case Value::Type::iVal: + { + xfer += prot_->serializedFieldSize("iVal", apache::thrift::protocol::T_I64, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::serializedSize(*prot_, this->get_iVal()); + break; + } + case Value::Type::fVal: + { + xfer += prot_->serializedFieldSize("fVal", apache::thrift::protocol::T_DOUBLE, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::floating_point, double>::serializedSize(*prot_, this->get_fVal()); + break; + } + case Value::Type::sVal: + { + xfer += prot_->serializedFieldSize("sVal", apache::thrift::protocol::T_STRING, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->get_sVal()); + break; + } + case Value::Type::dVal: + { + xfer += prot_->serializedFieldSize("dVal", apache::thrift::protocol::T_STRUCT, 6); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::Date>::serializedSize(*prot_, this->get_dVal()); + break; + } + case Value::Type::tVal: + { + xfer += prot_->serializedFieldSize("tVal", apache::thrift::protocol::T_STRUCT, 7); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::Time>::serializedSize(*prot_, this->get_tVal()); + break; + } + case Value::Type::dtVal: + { + xfer += prot_->serializedFieldSize("dtVal", apache::thrift::protocol::T_STRUCT, 8); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::DateTime>::serializedSize(*prot_, this->get_dtVal()); + break; + } + case Value::Type::vVal: + { + xfer += prot_->serializedFieldSize("vVal", apache::thrift::protocol::T_STRUCT, 9); + if (this->get_vVal()) { + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::Vertex>::serializedSize(*prot_, *this->get_vVal()); + } + else { + xfer += prot_->serializedStructSize("Vertex"); + xfer += prot_->serializedSizeStop(); + } + break; + } + case Value::Type::eVal: + { + xfer += prot_->serializedFieldSize("eVal", apache::thrift::protocol::T_STRUCT, 10); + if (this->get_eVal()) { + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::Edge>::serializedSize(*prot_, *this->get_eVal()); + } + else { + xfer += prot_->serializedStructSize("Edge"); + xfer += prot_->serializedSizeStop(); + } + break; + } + case Value::Type::pVal: + { + xfer += prot_->serializedFieldSize("pVal", apache::thrift::protocol::T_STRUCT, 11); + if (this->get_pVal()) { + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::Path>::serializedSize(*prot_, *this->get_pVal()); + } + else { + xfer += prot_->serializedStructSize("Path"); + xfer += prot_->serializedSizeStop(); + } + break; + } + case Value::Type::lVal: + { + xfer += prot_->serializedFieldSize("lVal", apache::thrift::protocol::T_STRUCT, 12); + if (this->get_lVal()) { + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::List>::serializedSize(*prot_, *this->get_lVal()); + } + else { + xfer += prot_->serializedStructSize("NList"); + xfer += prot_->serializedSizeStop(); + } + break; + } + case Value::Type::mVal: + { + xfer += prot_->serializedFieldSize("mVal", apache::thrift::protocol::T_STRUCT, 13); + if (this->get_mVal()) { + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::Map>::serializedSize(*prot_, *this->get_mVal()); + } + else { + xfer += prot_->serializedStructSize("NMap"); + xfer += prot_->serializedSizeStop(); + } + break; + } + case Value::Type::uVal: + { + xfer += prot_->serializedFieldSize("uVal", apache::thrift::protocol::T_STRUCT, 14); + if (this->get_uVal()) { + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::Set>::serializedSize(*prot_, *this->get_uVal()); + } + else { + xfer += prot_->serializedStructSize("NSet"); + xfer += prot_->serializedSizeStop(); + } + break; + } + case Value::Type::gVal: + { + xfer += prot_->serializedFieldSize("gVal", apache::thrift::protocol::T_STRUCT, 15); + if (this->get_gVal()) { + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::DataSet>::serializedSize(*prot_, *this->get_gVal()); + } + else { + xfer += prot_->serializedStructSize("DataSet"); + xfer += prot_->serializedSizeStop(); + } + break; + } + case Value::Type::ggVal: + { + xfer += prot_->serializedFieldSize("ggVal", apache::thrift::protocol::T_STRUCT, 16); + if (this->get_ggVal()) { + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::Geography>::serializedSize(*prot_, *this->get_ggVal()); + } + else { + xfer += prot_->serializedStructSize("Geography"); + xfer += prot_->serializedSizeStop(); + } + break; + } + case Value::Type::__EMPTY__:; + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t Value::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("Value"); + switch(this->getType()) { + case Value::Type::nVal: + { + xfer += prot_->serializedFieldSize("nVal", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, nebula::NullType>::serializedSize(*prot_, this->get_nVal()); + break; + } + case Value::Type::bVal: + { + xfer += prot_->serializedFieldSize("bVal", apache::thrift::protocol::T_BOOL, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::serializedSize(*prot_, this->get_bVal()); + break; + } + case Value::Type::iVal: + { + xfer += prot_->serializedFieldSize("iVal", apache::thrift::protocol::T_I64, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::serializedSize(*prot_, this->get_iVal()); + break; + } + case Value::Type::fVal: + { + xfer += prot_->serializedFieldSize("fVal", apache::thrift::protocol::T_DOUBLE, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::floating_point, double>::serializedSize(*prot_, this->get_fVal()); + break; + } + case Value::Type::sVal: + { + xfer += prot_->serializedFieldSize("sVal", apache::thrift::protocol::T_STRING, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->get_sVal()); + break; + } + case Value::Type::dVal: + { + xfer += prot_->serializedFieldSize("dVal", apache::thrift::protocol::T_STRUCT, 6); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::Date>::serializedSize(*prot_, this->get_dVal()); + break; + } + case Value::Type::tVal: + { + xfer += prot_->serializedFieldSize("tVal", apache::thrift::protocol::T_STRUCT, 7); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::Time>::serializedSize(*prot_, this->get_tVal()); + break; + } + case Value::Type::dtVal: + { + xfer += prot_->serializedFieldSize("dtVal", apache::thrift::protocol::T_STRUCT, 8); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::DateTime>::serializedSize(*prot_, this->get_dtVal()); + break; + } + case Value::Type::vVal: + { + xfer += prot_->serializedFieldSize("vVal", apache::thrift::protocol::T_STRUCT, 9); + if (this->get_vVal()) { + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::Vertex>::serializedSize(*prot_, *this->get_vVal()); + } + else { + xfer += prot_->serializedStructSize("Vertex"); + xfer += prot_->serializedSizeStop(); + } + break; + } + case Value::Type::eVal: + { + xfer += prot_->serializedFieldSize("eVal", apache::thrift::protocol::T_STRUCT, 10); + if (this->get_eVal()) { + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::Edge>::serializedSize(*prot_, *this->get_eVal()); + } + else { + xfer += prot_->serializedStructSize("Edge"); + xfer += prot_->serializedSizeStop(); + } + break; + } + case Value::Type::pVal: + { + xfer += prot_->serializedFieldSize("pVal", apache::thrift::protocol::T_STRUCT, 11); + if (this->get_pVal()) { + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::Path>::serializedSize(*prot_, *this->get_pVal()); + } + else { + xfer += prot_->serializedStructSize("Path"); + xfer += prot_->serializedSizeStop(); + } + break; + } + case Value::Type::lVal: + { + xfer += prot_->serializedFieldSize("lVal", apache::thrift::protocol::T_STRUCT, 12); + if (this->get_lVal()) { + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::List>::serializedSize(*prot_, *this->get_lVal()); + } + else { + xfer += prot_->serializedStructSize("NList"); + xfer += prot_->serializedSizeStop(); + } + break; + } + case Value::Type::mVal: + { + xfer += prot_->serializedFieldSize("mVal", apache::thrift::protocol::T_STRUCT, 13); + if (this->get_mVal()) { + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::Map>::serializedSize(*prot_, *this->get_mVal()); + } + else { + xfer += prot_->serializedStructSize("NMap"); + xfer += prot_->serializedSizeStop(); + } + break; + } + case Value::Type::uVal: + { + xfer += prot_->serializedFieldSize("uVal", apache::thrift::protocol::T_STRUCT, 14); + if (this->get_uVal()) { + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::Set>::serializedSize(*prot_, *this->get_uVal()); + } + else { + xfer += prot_->serializedStructSize("NSet"); + xfer += prot_->serializedSizeStop(); + } + break; + } + case Value::Type::gVal: + { + xfer += prot_->serializedFieldSize("gVal", apache::thrift::protocol::T_STRUCT, 15); + if (this->get_gVal()) { + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::DataSet>::serializedSize(*prot_, *this->get_gVal()); + } + else { + xfer += prot_->serializedStructSize("DataSet"); + xfer += prot_->serializedSizeStop(); + } + break; + } + case Value::Type::ggVal: + { + xfer += prot_->serializedFieldSize("ggVal", apache::thrift::protocol::T_STRUCT, 16); + if (this->get_ggVal()) { + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::Geography>::serializedSize(*prot_, *this->get_ggVal()); + } + else { + xfer += prot_->serializedStructSize("Geography"); + xfer += prot_->serializedSizeStop(); + } + break; + } + case Value::Type::__EMPTY__:; + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t Value::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("Value"); + switch(this->getType()) { + case Value::Type::nVal: + { + xfer += prot_->writeFieldBegin("nVal", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, nebula::NullType>::write(*prot_, this->get_nVal()); + xfer += prot_->writeFieldEnd(); + break; + } + case Value::Type::bVal: + { + xfer += prot_->writeFieldBegin("bVal", apache::thrift::protocol::T_BOOL, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::write(*prot_, this->get_bVal()); + xfer += prot_->writeFieldEnd(); + break; + } + case Value::Type::iVal: + { + xfer += prot_->writeFieldBegin("iVal", apache::thrift::protocol::T_I64, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::write(*prot_, this->get_iVal()); + xfer += prot_->writeFieldEnd(); + break; + } + case Value::Type::fVal: + { + xfer += prot_->writeFieldBegin("fVal", apache::thrift::protocol::T_DOUBLE, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::floating_point, double>::write(*prot_, this->get_fVal()); + xfer += prot_->writeFieldEnd(); + break; + } + case Value::Type::sVal: + { + xfer += prot_->writeFieldBegin("sVal", apache::thrift::protocol::T_STRING, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->get_sVal()); + xfer += prot_->writeFieldEnd(); + break; + } + case Value::Type::dVal: + { + xfer += prot_->writeFieldBegin("dVal", apache::thrift::protocol::T_STRUCT, 6); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::Date>::write(*prot_, this->get_dVal()); + xfer += prot_->writeFieldEnd(); + break; + } + case Value::Type::tVal: + { + xfer += prot_->writeFieldBegin("tVal", apache::thrift::protocol::T_STRUCT, 7); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::Time>::write(*prot_, this->get_tVal()); + xfer += prot_->writeFieldEnd(); + break; + } + case Value::Type::dtVal: + { + xfer += prot_->writeFieldBegin("dtVal", apache::thrift::protocol::T_STRUCT, 8); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::DateTime>::write(*prot_, this->get_dtVal()); + xfer += prot_->writeFieldEnd(); + break; + } + case Value::Type::vVal: + { + xfer += prot_->writeFieldBegin("vVal", apache::thrift::protocol::T_STRUCT, 9); + if (this->get_vVal()) { + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::Vertex>::write(*prot_, *this->get_vVal()); + } + else { + xfer += prot_->writeStructBegin("Vertex"); + xfer += prot_->writeStructEnd(); + xfer += prot_->writeFieldStop(); + } + xfer += prot_->writeFieldEnd(); + break; + } + case Value::Type::eVal: + { + xfer += prot_->writeFieldBegin("eVal", apache::thrift::protocol::T_STRUCT, 10); + if (this->get_eVal()) { + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::Edge>::write(*prot_, *this->get_eVal()); + } + else { + xfer += prot_->writeStructBegin("Edge"); + xfer += prot_->writeStructEnd(); + xfer += prot_->writeFieldStop(); + } + xfer += prot_->writeFieldEnd(); + break; + } + case Value::Type::pVal: + { + xfer += prot_->writeFieldBegin("pVal", apache::thrift::protocol::T_STRUCT, 11); + if (this->get_pVal()) { + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::Path>::write(*prot_, *this->get_pVal()); + } + else { + xfer += prot_->writeStructBegin("Path"); + xfer += prot_->writeStructEnd(); + xfer += prot_->writeFieldStop(); + } + xfer += prot_->writeFieldEnd(); + break; + } + case Value::Type::lVal: + { + xfer += prot_->writeFieldBegin("lVal", apache::thrift::protocol::T_STRUCT, 12); + if (this->get_lVal()) { + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::List>::write(*prot_, *this->get_lVal()); + } + else { + xfer += prot_->writeStructBegin("NList"); + xfer += prot_->writeStructEnd(); + xfer += prot_->writeFieldStop(); + } + xfer += prot_->writeFieldEnd(); + break; + } + case Value::Type::mVal: + { + xfer += prot_->writeFieldBegin("mVal", apache::thrift::protocol::T_STRUCT, 13); + if (this->get_mVal()) { + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::Map>::write(*prot_, *this->get_mVal()); + } + else { + xfer += prot_->writeStructBegin("NMap"); + xfer += prot_->writeStructEnd(); + xfer += prot_->writeFieldStop(); + } + xfer += prot_->writeFieldEnd(); + break; + } + case Value::Type::uVal: + { + xfer += prot_->writeFieldBegin("uVal", apache::thrift::protocol::T_STRUCT, 14); + if (this->get_uVal()) { + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::Set>::write(*prot_, *this->get_uVal()); + } + else { + xfer += prot_->writeStructBegin("NSet"); + xfer += prot_->writeStructEnd(); + xfer += prot_->writeFieldStop(); + } + xfer += prot_->writeFieldEnd(); + break; + } + case Value::Type::gVal: + { + xfer += prot_->writeFieldBegin("gVal", apache::thrift::protocol::T_STRUCT, 15); + if (this->get_gVal()) { + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::DataSet>::write(*prot_, *this->get_gVal()); + } + else { + xfer += prot_->writeStructBegin("DataSet"); + xfer += prot_->writeStructEnd(); + xfer += prot_->writeFieldStop(); + } + xfer += prot_->writeFieldEnd(); + break; + } + case Value::Type::ggVal: + { + xfer += prot_->writeFieldBegin("ggVal", apache::thrift::protocol::T_STRUCT, 16); + if (this->get_ggVal()) { + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::Geography>::write(*prot_, *this->get_ggVal()); + } + else { + xfer += prot_->writeStructBegin("Geography"); + xfer += prot_->writeStructEnd(); + xfer += prot_->writeFieldStop(); + } + xfer += prot_->writeFieldEnd(); + break; + } + case Value::Type::__EMPTY__:; + } + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void Value::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t Value::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t Value::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t Value::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void Value::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t Value::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t Value::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t Value::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}} // nebula::cpp2 +namespace nebula { namespace cpp2 { + +template +void NList::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_values: + { + _readState.beforeSubobject(iprot); + this->values = ::std::vector(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::variant>, ::std::vector>::readWithContext(*iprot, this->values, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.values = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_values; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t NList::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("NList"); + xfer += prot_->serializedFieldSize("values", apache::thrift::protocol::T_LIST, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::variant>, ::std::vector>::serializedSize(*prot_, this->values); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t NList::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("NList"); + xfer += prot_->serializedFieldSize("values", apache::thrift::protocol::T_LIST, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::variant>, ::std::vector>::serializedSize(*prot_, this->values); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t NList::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("NList"); + xfer += prot_->writeFieldBegin("values", apache::thrift::protocol::T_LIST, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::variant>, ::std::vector>::write(*prot_, this->values); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void NList::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t NList::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t NList::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t NList::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void NList::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t NList::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t NList::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t NList::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}} // nebula::cpp2 +namespace nebula { namespace cpp2 { + +template +void NMap::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_MAP))) { + goto _loop; + } +_readField_kvs: + { + _readState.beforeSubobject(iprot); + this->kvs = std::unordered_map<::std::string, nebula::Value>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::binary, ::apache::thrift::type_class::variant>, std::unordered_map<::std::string, nebula::Value>>::readWithContext(*iprot, this->kvs, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.kvs = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_MAP))) { + goto _readField_kvs; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t NMap::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("NMap"); + xfer += prot_->serializedFieldSize("kvs", apache::thrift::protocol::T_MAP, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::binary, ::apache::thrift::type_class::variant>, std::unordered_map<::std::string, nebula::Value>>::serializedSize(*prot_, this->kvs); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t NMap::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("NMap"); + xfer += prot_->serializedFieldSize("kvs", apache::thrift::protocol::T_MAP, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::binary, ::apache::thrift::type_class::variant>, std::unordered_map<::std::string, nebula::Value>>::serializedSize(*prot_, this->kvs); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t NMap::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("NMap"); + xfer += prot_->writeFieldBegin("kvs", apache::thrift::protocol::T_MAP, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::binary, ::apache::thrift::type_class::variant>, std::unordered_map<::std::string, nebula::Value>>::write(*prot_, this->kvs); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void NMap::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t NMap::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t NMap::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t NMap::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void NMap::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t NMap::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t NMap::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t NMap::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}} // nebula::cpp2 +namespace nebula { namespace cpp2 { + +template +void NSet::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_SET))) { + goto _loop; + } +_readField_values: + { + _readState.beforeSubobject(iprot); + this->values = std::unordered_set(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::set<::apache::thrift::type_class::variant>, std::unordered_set>::readWithContext(*iprot, this->values, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.values = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_SET))) { + goto _readField_values; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t NSet::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("NSet"); + xfer += prot_->serializedFieldSize("values", apache::thrift::protocol::T_SET, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::set<::apache::thrift::type_class::variant>, std::unordered_set>::serializedSize(*prot_, this->values); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t NSet::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("NSet"); + xfer += prot_->serializedFieldSize("values", apache::thrift::protocol::T_SET, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::set<::apache::thrift::type_class::variant>, std::unordered_set>::serializedSize(*prot_, this->values); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t NSet::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("NSet"); + xfer += prot_->writeFieldBegin("values", apache::thrift::protocol::T_SET, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::set<::apache::thrift::type_class::variant>, std::unordered_set>::write(*prot_, this->values); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void NSet::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t NSet::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t NSet::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t NSet::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void NSet::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t NSet::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t NSet::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t NSet::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}} // nebula::cpp2 +namespace nebula { namespace cpp2 { + +template +void Row::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_values: + { + _readState.beforeSubobject(iprot); + this->values = ::std::vector(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::variant>, ::std::vector>::readWithContext(*iprot, this->values, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.values = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_values; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t Row::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("Row"); + xfer += prot_->serializedFieldSize("values", apache::thrift::protocol::T_LIST, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::variant>, ::std::vector>::serializedSize(*prot_, this->values); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t Row::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("Row"); + xfer += prot_->serializedFieldSize("values", apache::thrift::protocol::T_LIST, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::variant>, ::std::vector>::serializedSize(*prot_, this->values); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t Row::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("Row"); + xfer += prot_->writeFieldBegin("values", apache::thrift::protocol::T_LIST, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::variant>, ::std::vector>::write(*prot_, this->values); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void Row::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t Row::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t Row::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t Row::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void Row::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t Row::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t Row::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t Row::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}} // nebula::cpp2 +namespace nebula { namespace cpp2 { + +template +void DataSet::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_column_names: + { + _readState.beforeSubobject(iprot); + this->column_names = ::std::vector<::std::string>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>, ::std::vector<::std::string>>::readWithContext(*iprot, this->column_names, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.column_names = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_rows: + { + _readState.beforeSubobject(iprot); + this->rows = ::std::vector(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector>::readWithContext(*iprot, this->rows, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.rows = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_column_names; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_rows; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t DataSet::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("DataSet"); + xfer += prot_->serializedFieldSize("column_names", apache::thrift::protocol::T_LIST, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>, ::std::vector<::std::string>>::serializedSize(*prot_, this->column_names); + xfer += prot_->serializedFieldSize("rows", apache::thrift::protocol::T_LIST, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector>::serializedSize(*prot_, this->rows); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t DataSet::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("DataSet"); + xfer += prot_->serializedFieldSize("column_names", apache::thrift::protocol::T_LIST, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>, ::std::vector<::std::string>>::serializedSize(*prot_, this->column_names); + xfer += prot_->serializedFieldSize("rows", apache::thrift::protocol::T_LIST, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector>::serializedSize(*prot_, this->rows); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t DataSet::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("DataSet"); + xfer += prot_->writeFieldBegin("column_names", apache::thrift::protocol::T_LIST, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>, ::std::vector<::std::string>>::write(*prot_, this->column_names); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("rows", apache::thrift::protocol::T_LIST, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector>::write(*prot_, this->rows); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void DataSet::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t DataSet::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t DataSet::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t DataSet::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void DataSet::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t DataSet::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t DataSet::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t DataSet::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}} // nebula::cpp2 +namespace nebula { namespace cpp2 { + +template +void Geography::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_wkb: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::string, ::std::string>::readWithContext(*iprot, this->wkb, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.wkb = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_wkb; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t Geography::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("Geography"); + xfer += prot_->serializedFieldSize("wkb", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::string, ::std::string>::serializedSize(*prot_, this->wkb); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t Geography::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("Geography"); + xfer += prot_->serializedFieldSize("wkb", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::string, ::std::string>::serializedSize(*prot_, this->wkb); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t Geography::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("Geography"); + xfer += prot_->writeFieldBegin("wkb", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::string, ::std::string>::write(*prot_, this->wkb); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void Geography::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t Geography::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t Geography::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t Geography::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void Geography::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t Geography::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t Geography::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t Geography::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}} // nebula::cpp2 +namespace nebula { namespace cpp2 { + +template +void Tag::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_name: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->name, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.name = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_MAP))) { + goto _loop; + } +_readField_props: + { + _readState.beforeSubobject(iprot); + this->props = std::unordered_map<::std::string, nebula::Value>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::binary, ::apache::thrift::type_class::variant>, std::unordered_map<::std::string, nebula::Value>>::readWithContext(*iprot, this->props, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.props = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_name; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_MAP))) { + goto _readField_props; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t Tag::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("Tag"); + xfer += prot_->serializedFieldSize("name", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->name); + xfer += prot_->serializedFieldSize("props", apache::thrift::protocol::T_MAP, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::binary, ::apache::thrift::type_class::variant>, std::unordered_map<::std::string, nebula::Value>>::serializedSize(*prot_, this->props); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t Tag::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("Tag"); + xfer += prot_->serializedFieldSize("name", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->name); + xfer += prot_->serializedFieldSize("props", apache::thrift::protocol::T_MAP, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::binary, ::apache::thrift::type_class::variant>, std::unordered_map<::std::string, nebula::Value>>::serializedSize(*prot_, this->props); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t Tag::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("Tag"); + xfer += prot_->writeFieldBegin("name", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->name); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("props", apache::thrift::protocol::T_MAP, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::binary, ::apache::thrift::type_class::variant>, std::unordered_map<::std::string, nebula::Value>>::write(*prot_, this->props); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void Tag::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t Tag::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t Tag::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t Tag::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void Tag::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t Tag::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t Tag::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t Tag::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}} // nebula::cpp2 +namespace nebula { namespace cpp2 { + +template +void Vertex::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_vid: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::variant, nebula::Value>::readWithContext(*iprot, this->vid, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.vid = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_tags: + { + _readState.beforeSubobject(iprot); + this->tags = ::std::vector(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector>::readWithContext(*iprot, this->tags, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.tags = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_vid; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_tags; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t Vertex::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("Vertex"); + xfer += prot_->serializedFieldSize("vid", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::variant, nebula::Value>::serializedSize(*prot_, this->vid); + xfer += prot_->serializedFieldSize("tags", apache::thrift::protocol::T_LIST, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector>::serializedSize(*prot_, this->tags); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t Vertex::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("Vertex"); + xfer += prot_->serializedFieldSize("vid", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::variant, nebula::Value>::serializedSize(*prot_, this->vid); + xfer += prot_->serializedFieldSize("tags", apache::thrift::protocol::T_LIST, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector>::serializedSize(*prot_, this->tags); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t Vertex::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("Vertex"); + xfer += prot_->writeFieldBegin("vid", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::variant, nebula::Value>::write(*prot_, this->vid); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("tags", apache::thrift::protocol::T_LIST, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector>::write(*prot_, this->tags); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void Vertex::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t Vertex::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t Vertex::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t Vertex::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void Vertex::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t Vertex::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t Vertex::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t Vertex::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}} // nebula::cpp2 +namespace nebula { namespace cpp2 { + +template +void Edge::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_src: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::variant, nebula::Value>::readWithContext(*iprot, this->src, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.src = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_dst: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::variant, nebula::Value>::readWithContext(*iprot, this->dst, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.dst = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_type: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::EdgeType>::readWithContext(*iprot, this->type, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.type = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 4, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_name: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->name, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.name = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 4, + 5, + apache::thrift::protocol::T_I64))) { + goto _loop; + } +_readField_ranking: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::EdgeRanking>::readWithContext(*iprot, this->ranking, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.ranking = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 5, + 6, + apache::thrift::protocol::T_MAP))) { + goto _loop; + } +_readField_props: + { + _readState.beforeSubobject(iprot); + this->props = std::unordered_map<::std::string, nebula::Value>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::binary, ::apache::thrift::type_class::variant>, std::unordered_map<::std::string, nebula::Value>>::readWithContext(*iprot, this->props, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.props = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 6, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_src; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_dst; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_type; + } else { + goto _skip; + } + } + case 4: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_name; + } else { + goto _skip; + } + } + case 5: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I64))) { + goto _readField_ranking; + } else { + goto _skip; + } + } + case 6: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_MAP))) { + goto _readField_props; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t Edge::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("Edge"); + xfer += prot_->serializedFieldSize("src", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::variant, nebula::Value>::serializedSize(*prot_, this->src); + xfer += prot_->serializedFieldSize("dst", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::variant, nebula::Value>::serializedSize(*prot_, this->dst); + xfer += prot_->serializedFieldSize("type", apache::thrift::protocol::T_I32, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::EdgeType>::serializedSize(*prot_, this->type); + xfer += prot_->serializedFieldSize("name", apache::thrift::protocol::T_STRING, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->name); + xfer += prot_->serializedFieldSize("ranking", apache::thrift::protocol::T_I64, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::EdgeRanking>::serializedSize(*prot_, this->ranking); + xfer += prot_->serializedFieldSize("props", apache::thrift::protocol::T_MAP, 6); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::binary, ::apache::thrift::type_class::variant>, std::unordered_map<::std::string, nebula::Value>>::serializedSize(*prot_, this->props); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t Edge::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("Edge"); + xfer += prot_->serializedFieldSize("src", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::variant, nebula::Value>::serializedSize(*prot_, this->src); + xfer += prot_->serializedFieldSize("dst", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::variant, nebula::Value>::serializedSize(*prot_, this->dst); + xfer += prot_->serializedFieldSize("type", apache::thrift::protocol::T_I32, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::EdgeType>::serializedSize(*prot_, this->type); + xfer += prot_->serializedFieldSize("name", apache::thrift::protocol::T_STRING, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->name); + xfer += prot_->serializedFieldSize("ranking", apache::thrift::protocol::T_I64, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::EdgeRanking>::serializedSize(*prot_, this->ranking); + xfer += prot_->serializedFieldSize("props", apache::thrift::protocol::T_MAP, 6); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::binary, ::apache::thrift::type_class::variant>, std::unordered_map<::std::string, nebula::Value>>::serializedSize(*prot_, this->props); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t Edge::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("Edge"); + xfer += prot_->writeFieldBegin("src", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::variant, nebula::Value>::write(*prot_, this->src); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("dst", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::variant, nebula::Value>::write(*prot_, this->dst); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("type", apache::thrift::protocol::T_I32, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::EdgeType>::write(*prot_, this->type); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("name", apache::thrift::protocol::T_STRING, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->name); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("ranking", apache::thrift::protocol::T_I64, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::EdgeRanking>::write(*prot_, this->ranking); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("props", apache::thrift::protocol::T_MAP, 6); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::binary, ::apache::thrift::type_class::variant>, std::unordered_map<::std::string, nebula::Value>>::write(*prot_, this->props); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void Edge::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t Edge::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t Edge::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t Edge::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void Edge::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t Edge::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t Edge::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t Edge::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}} // nebula::cpp2 +namespace nebula { namespace cpp2 { + +template +void Step::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_dst: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::Vertex>::readWithContext(*iprot, this->dst, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.dst = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_type: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::EdgeType>::readWithContext(*iprot, this->type, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.type = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_name: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->name, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.name = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 4, + apache::thrift::protocol::T_I64))) { + goto _loop; + } +_readField_ranking: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::EdgeRanking>::readWithContext(*iprot, this->ranking, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.ranking = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 4, + 5, + apache::thrift::protocol::T_MAP))) { + goto _loop; + } +_readField_props: + { + _readState.beforeSubobject(iprot); + this->props = std::unordered_map<::std::string, nebula::Value>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::binary, ::apache::thrift::type_class::variant>, std::unordered_map<::std::string, nebula::Value>>::readWithContext(*iprot, this->props, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.props = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 5, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_dst; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_type; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_name; + } else { + goto _skip; + } + } + case 4: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I64))) { + goto _readField_ranking; + } else { + goto _skip; + } + } + case 5: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_MAP))) { + goto _readField_props; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t Step::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("Step"); + xfer += prot_->serializedFieldSize("dst", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::Vertex>::serializedSize(*prot_, this->dst); + xfer += prot_->serializedFieldSize("type", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::EdgeType>::serializedSize(*prot_, this->type); + xfer += prot_->serializedFieldSize("name", apache::thrift::protocol::T_STRING, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->name); + xfer += prot_->serializedFieldSize("ranking", apache::thrift::protocol::T_I64, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::EdgeRanking>::serializedSize(*prot_, this->ranking); + xfer += prot_->serializedFieldSize("props", apache::thrift::protocol::T_MAP, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::binary, ::apache::thrift::type_class::variant>, std::unordered_map<::std::string, nebula::Value>>::serializedSize(*prot_, this->props); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t Step::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("Step"); + xfer += prot_->serializedFieldSize("dst", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::Vertex>::serializedSize(*prot_, this->dst); + xfer += prot_->serializedFieldSize("type", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::EdgeType>::serializedSize(*prot_, this->type); + xfer += prot_->serializedFieldSize("name", apache::thrift::protocol::T_STRING, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->name); + xfer += prot_->serializedFieldSize("ranking", apache::thrift::protocol::T_I64, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::EdgeRanking>::serializedSize(*prot_, this->ranking); + xfer += prot_->serializedFieldSize("props", apache::thrift::protocol::T_MAP, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::binary, ::apache::thrift::type_class::variant>, std::unordered_map<::std::string, nebula::Value>>::serializedSize(*prot_, this->props); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t Step::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("Step"); + xfer += prot_->writeFieldBegin("dst", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::Vertex>::write(*prot_, this->dst); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("type", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::EdgeType>::write(*prot_, this->type); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("name", apache::thrift::protocol::T_STRING, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->name); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("ranking", apache::thrift::protocol::T_I64, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::EdgeRanking>::write(*prot_, this->ranking); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("props", apache::thrift::protocol::T_MAP, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::binary, ::apache::thrift::type_class::variant>, std::unordered_map<::std::string, nebula::Value>>::write(*prot_, this->props); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void Step::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t Step::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t Step::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t Step::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void Step::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t Step::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t Step::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t Step::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}} // nebula::cpp2 +namespace nebula { namespace cpp2 { + +template +void Path::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_src: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::Vertex>::readWithContext(*iprot, this->src, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.src = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_steps: + { + _readState.beforeSubobject(iprot); + this->steps = ::std::vector(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector>::readWithContext(*iprot, this->steps, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.steps = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_src; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_steps; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t Path::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("Path"); + xfer += prot_->serializedFieldSize("src", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::Vertex>::serializedSize(*prot_, this->src); + xfer += prot_->serializedFieldSize("steps", apache::thrift::protocol::T_LIST, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector>::serializedSize(*prot_, this->steps); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t Path::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("Path"); + xfer += prot_->serializedFieldSize("src", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::Vertex>::serializedSize(*prot_, this->src); + xfer += prot_->serializedFieldSize("steps", apache::thrift::protocol::T_LIST, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector>::serializedSize(*prot_, this->steps); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t Path::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("Path"); + xfer += prot_->writeFieldBegin("src", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::Vertex>::write(*prot_, this->src); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("steps", apache::thrift::protocol::T_LIST, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector>::write(*prot_, this->steps); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void Path::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t Path::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t Path::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t Path::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void Path::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t Path::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t Path::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t Path::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}} // nebula::cpp2 +namespace nebula { namespace cpp2 { + +template +void HostAddr::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_host: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::string, ::std::string>::readWithContext(*iprot, this->host, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.host = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_port: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::Port>::readWithContext(*iprot, this->port, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.port = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_host; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_port; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t HostAddr::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("HostAddr"); + xfer += prot_->serializedFieldSize("host", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::string, ::std::string>::serializedSize(*prot_, this->host); + xfer += prot_->serializedFieldSize("port", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::Port>::serializedSize(*prot_, this->port); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t HostAddr::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("HostAddr"); + xfer += prot_->serializedFieldSize("host", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::string, ::std::string>::serializedSize(*prot_, this->host); + xfer += prot_->serializedFieldSize("port", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::Port>::serializedSize(*prot_, this->port); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t HostAddr::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("HostAddr"); + xfer += prot_->writeFieldBegin("host", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::string, ::std::string>::write(*prot_, this->host); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("port", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::Port>::write(*prot_, this->port); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void HostAddr::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t HostAddr::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t HostAddr::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t HostAddr::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void HostAddr::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t HostAddr::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t HostAddr::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t HostAddr::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}} // nebula::cpp2 +namespace nebula { namespace cpp2 { + +template +void KeyValue::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_key: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->key, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.key = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_value: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->value, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.value = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_key; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_value; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t KeyValue::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("KeyValue"); + xfer += prot_->serializedFieldSize("key", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->key); + xfer += prot_->serializedFieldSize("value", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->value); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t KeyValue::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("KeyValue"); + xfer += prot_->serializedFieldSize("key", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->key); + xfer += prot_->serializedFieldSize("value", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->value); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t KeyValue::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("KeyValue"); + xfer += prot_->writeFieldBegin("key", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->key); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("value", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->value); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void KeyValue::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t KeyValue::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t KeyValue::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t KeyValue::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void KeyValue::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t KeyValue::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t KeyValue::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t KeyValue::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}} // nebula::cpp2 +namespace nebula { namespace cpp2 { + +template +void LogInfo::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I64))) { + goto _loop; + } +_readField_log_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::LogID>::readWithContext(*iprot, this->log_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.log_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_I64))) { + goto _loop; + } +_readField_term_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::TermID>::readWithContext(*iprot, this->term_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.term_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I64))) { + goto _readField_log_id; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I64))) { + goto _readField_term_id; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t LogInfo::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("LogInfo"); + xfer += prot_->serializedFieldSize("log_id", apache::thrift::protocol::T_I64, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::LogID>::serializedSize(*prot_, this->log_id); + xfer += prot_->serializedFieldSize("term_id", apache::thrift::protocol::T_I64, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::TermID>::serializedSize(*prot_, this->term_id); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t LogInfo::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("LogInfo"); + xfer += prot_->serializedFieldSize("log_id", apache::thrift::protocol::T_I64, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::LogID>::serializedSize(*prot_, this->log_id); + xfer += prot_->serializedFieldSize("term_id", apache::thrift::protocol::T_I64, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::TermID>::serializedSize(*prot_, this->term_id); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t LogInfo::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("LogInfo"); + xfer += prot_->writeFieldBegin("log_id", apache::thrift::protocol::T_I64, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::LogID>::write(*prot_, this->log_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("term_id", apache::thrift::protocol::T_I64, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::TermID>::write(*prot_, this->term_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void LogInfo::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t LogInfo::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t LogInfo::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t LogInfo::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void LogInfo::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t LogInfo::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t LogInfo::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t LogInfo::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}} // nebula::cpp2 +namespace nebula { namespace cpp2 { + +template +void DirInfo::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_root: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->root, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.root = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_data: + { + _readState.beforeSubobject(iprot); + this->data = ::std::vector<::std::string>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>, ::std::vector<::std::string>>::readWithContext(*iprot, this->data, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.data = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_root; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_data; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t DirInfo::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("DirInfo"); + xfer += prot_->serializedFieldSize("root", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->root); + xfer += prot_->serializedFieldSize("data", apache::thrift::protocol::T_LIST, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>, ::std::vector<::std::string>>::serializedSize(*prot_, this->data); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t DirInfo::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("DirInfo"); + xfer += prot_->serializedFieldSize("root", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->root); + xfer += prot_->serializedFieldSize("data", apache::thrift::protocol::T_LIST, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>, ::std::vector<::std::string>>::serializedSize(*prot_, this->data); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t DirInfo::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("DirInfo"); + xfer += prot_->writeFieldBegin("root", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->root); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("data", apache::thrift::protocol::T_LIST, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>, ::std::vector<::std::string>>::write(*prot_, this->data); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void DirInfo::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t DirInfo::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t DirInfo::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t DirInfo::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void DirInfo::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t DirInfo::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t DirInfo::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t DirInfo::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}} // nebula::cpp2 +namespace nebula { namespace cpp2 { + +template +void NodeInfo::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_host: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::readWithContext(*iprot, this->host, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.host = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_dir: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::cpp2::DirInfo>::readWithContext(*iprot, this->dir, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.dir = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_host; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_dir; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t NodeInfo::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("NodeInfo"); + xfer += prot_->serializedFieldSize("host", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->host); + xfer += prot_->serializedFieldSize("dir", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::cpp2::DirInfo>::serializedSize(*prot_, this->dir); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t NodeInfo::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("NodeInfo"); + xfer += prot_->serializedFieldSize("host", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->host); + xfer += prot_->serializedFieldSize("dir", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::cpp2::DirInfo>::serializedSize(*prot_, this->dir); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t NodeInfo::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("NodeInfo"); + xfer += prot_->writeFieldBegin("host", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::write(*prot_, this->host); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("dir", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::cpp2::DirInfo>::write(*prot_, this->dir); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void NodeInfo::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t NodeInfo::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t NodeInfo::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t NodeInfo::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void NodeInfo::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t NodeInfo::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t NodeInfo::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t NodeInfo::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}} // nebula::cpp2 +namespace nebula { namespace cpp2 { + +template +void PartitionBackupInfo::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_MAP))) { + goto _loop; + } +_readField_info: + { + _readState.beforeSubobject(iprot); + this->info = std::unordered_map< ::nebula::cpp2::PartitionID, ::nebula::cpp2::LogInfo>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::structure>, std::unordered_map< ::nebula::cpp2::PartitionID, ::nebula::cpp2::LogInfo>>::readWithContext(*iprot, this->info, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.info = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_MAP))) { + goto _readField_info; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t PartitionBackupInfo::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("PartitionBackupInfo"); + xfer += prot_->serializedFieldSize("info", apache::thrift::protocol::T_MAP, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::structure>, std::unordered_map< ::nebula::cpp2::PartitionID, ::nebula::cpp2::LogInfo>>::serializedSize(*prot_, this->info); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t PartitionBackupInfo::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("PartitionBackupInfo"); + xfer += prot_->serializedFieldSize("info", apache::thrift::protocol::T_MAP, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::structure>, std::unordered_map< ::nebula::cpp2::PartitionID, ::nebula::cpp2::LogInfo>>::serializedSize(*prot_, this->info); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t PartitionBackupInfo::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("PartitionBackupInfo"); + xfer += prot_->writeFieldBegin("info", apache::thrift::protocol::T_MAP, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::structure>, std::unordered_map< ::nebula::cpp2::PartitionID, ::nebula::cpp2::LogInfo>>::write(*prot_, this->info); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void PartitionBackupInfo::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t PartitionBackupInfo::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t PartitionBackupInfo::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t PartitionBackupInfo::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void PartitionBackupInfo::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t PartitionBackupInfo::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t PartitionBackupInfo::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t PartitionBackupInfo::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}} // nebula::cpp2 +namespace nebula { namespace cpp2 { + +template +void CheckpointInfo::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_partition_info: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::cpp2::PartitionBackupInfo>::readWithContext(*iprot, this->partition_info, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.partition_info = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_path: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->path, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.path = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_partition_info; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_path; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t CheckpointInfo::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("CheckpointInfo"); + xfer += prot_->serializedFieldSize("partition_info", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::cpp2::PartitionBackupInfo>::serializedSize(*prot_, this->partition_info); + xfer += prot_->serializedFieldSize("path", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->path); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t CheckpointInfo::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("CheckpointInfo"); + xfer += prot_->serializedFieldSize("partition_info", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::cpp2::PartitionBackupInfo>::serializedSize(*prot_, this->partition_info); + xfer += prot_->serializedFieldSize("path", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->path); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t CheckpointInfo::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("CheckpointInfo"); + xfer += prot_->writeFieldBegin("partition_info", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::cpp2::PartitionBackupInfo>::write(*prot_, this->partition_info); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("path", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->path); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void CheckpointInfo::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t CheckpointInfo::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t CheckpointInfo::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t CheckpointInfo::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void CheckpointInfo::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t CheckpointInfo::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t CheckpointInfo::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t CheckpointInfo::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}} // nebula::cpp2 diff --git a/src/interface/gen-cpp2/common_types_custom_protocol.h b/src/interface/gen-cpp2/common_types_custom_protocol.h new file mode 100644 index 00000000..24988da3 --- /dev/null +++ b/src/interface/gen-cpp2/common_types_custom_protocol.h @@ -0,0 +1,18 @@ +/** + * Autogenerated by Thrift for common.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#pragma once + + +/** + * This header file includes the tcc files of the corresponding header file + * and the header files of its dependent types. Include this header file + * only when you need to use custom protocols (e.g. DebugProtocol, + * VirtualProtocol) to read/write thrift structs. + */ + +#include "common_types.tcc" + diff --git a/src/interface/gen-cpp2/common_visit_by_thrift_field_metadata.h b/src/interface/gen-cpp2/common_visit_by_thrift_field_metadata.h new file mode 100644 index 00000000..05177be6 --- /dev/null +++ b/src/interface/gen-cpp2/common_visit_by_thrift_field_metadata.h @@ -0,0 +1,408 @@ +/** + * Autogenerated by Thrift for common.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#pragma once + +#include +#include "common_metadata.h" + +namespace apache { +namespace thrift { +namespace detail { + +template <> +struct VisitByThriftId<::nebula::cpp2::SchemaID> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).tag_id_ref()); + case 2: + return f(1, static_cast(t).edge_type_ref()); + default: + throwInvalidThriftId(id, "::nebula::cpp2::SchemaID"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::cpp2::Date> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).year_ref()); + case 2: + return f(1, static_cast(t).month_ref()); + case 3: + return f(2, static_cast(t).day_ref()); + default: + throwInvalidThriftId(id, "::nebula::cpp2::Date"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::cpp2::Time> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).hour_ref()); + case 2: + return f(1, static_cast(t).minute_ref()); + case 3: + return f(2, static_cast(t).sec_ref()); + case 4: + return f(3, static_cast(t).microsec_ref()); + default: + throwInvalidThriftId(id, "::nebula::cpp2::Time"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::cpp2::DateTime> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).year_ref()); + case 2: + return f(1, static_cast(t).month_ref()); + case 3: + return f(2, static_cast(t).day_ref()); + case 4: + return f(3, static_cast(t).hour_ref()); + case 5: + return f(4, static_cast(t).minute_ref()); + case 6: + return f(5, static_cast(t).sec_ref()); + case 7: + return f(6, static_cast(t).microsec_ref()); + default: + throwInvalidThriftId(id, "::nebula::cpp2::DateTime"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::cpp2::Value> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).nVal_ref()); + case 2: + return f(1, static_cast(t).bVal_ref()); + case 3: + return f(2, static_cast(t).iVal_ref()); + case 4: + return f(3, static_cast(t).fVal_ref()); + case 5: + return f(4, static_cast(t).sVal_ref()); + case 6: + return f(5, static_cast(t).dVal_ref()); + case 7: + return f(6, static_cast(t).tVal_ref()); + case 8: + return f(7, static_cast(t).dtVal_ref()); + case 9: + return f(8, static_cast(t).vVal_ref()); + case 10: + return f(9, static_cast(t).eVal_ref()); + case 11: + return f(10, static_cast(t).pVal_ref()); + case 12: + return f(11, static_cast(t).lVal_ref()); + case 13: + return f(12, static_cast(t).mVal_ref()); + case 14: + return f(13, static_cast(t).uVal_ref()); + case 15: + return f(14, static_cast(t).gVal_ref()); + case 16: + return f(15, static_cast(t).ggVal_ref()); + default: + throwInvalidThriftId(id, "::nebula::cpp2::Value"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::cpp2::NList> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).values_ref()); + default: + throwInvalidThriftId(id, "::nebula::cpp2::NList"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::cpp2::NMap> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).kvs_ref()); + default: + throwInvalidThriftId(id, "::nebula::cpp2::NMap"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::cpp2::NSet> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).values_ref()); + default: + throwInvalidThriftId(id, "::nebula::cpp2::NSet"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::cpp2::Row> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).values_ref()); + default: + throwInvalidThriftId(id, "::nebula::cpp2::Row"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::cpp2::DataSet> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).column_names_ref()); + case 2: + return f(1, static_cast(t).rows_ref()); + default: + throwInvalidThriftId(id, "::nebula::cpp2::DataSet"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::cpp2::Geography> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).wkb_ref()); + default: + throwInvalidThriftId(id, "::nebula::cpp2::Geography"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::cpp2::Tag> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).name_ref()); + case 2: + return f(1, static_cast(t).props_ref()); + default: + throwInvalidThriftId(id, "::nebula::cpp2::Tag"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::cpp2::Vertex> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).vid_ref()); + case 2: + return f(1, static_cast(t).tags_ref()); + default: + throwInvalidThriftId(id, "::nebula::cpp2::Vertex"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::cpp2::Edge> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).src_ref()); + case 2: + return f(1, static_cast(t).dst_ref()); + case 3: + return f(2, static_cast(t).type_ref()); + case 4: + return f(3, static_cast(t).name_ref()); + case 5: + return f(4, static_cast(t).ranking_ref()); + case 6: + return f(5, static_cast(t).props_ref()); + default: + throwInvalidThriftId(id, "::nebula::cpp2::Edge"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::cpp2::Step> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).dst_ref()); + case 2: + return f(1, static_cast(t).type_ref()); + case 3: + return f(2, static_cast(t).name_ref()); + case 4: + return f(3, static_cast(t).ranking_ref()); + case 5: + return f(4, static_cast(t).props_ref()); + default: + throwInvalidThriftId(id, "::nebula::cpp2::Step"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::cpp2::Path> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).src_ref()); + case 2: + return f(1, static_cast(t).steps_ref()); + default: + throwInvalidThriftId(id, "::nebula::cpp2::Path"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::cpp2::HostAddr> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).host_ref()); + case 2: + return f(1, static_cast(t).port_ref()); + default: + throwInvalidThriftId(id, "::nebula::cpp2::HostAddr"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::cpp2::KeyValue> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).key_ref()); + case 2: + return f(1, static_cast(t).value_ref()); + default: + throwInvalidThriftId(id, "::nebula::cpp2::KeyValue"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::cpp2::LogInfo> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).log_id_ref()); + case 2: + return f(1, static_cast(t).term_id_ref()); + default: + throwInvalidThriftId(id, "::nebula::cpp2::LogInfo"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::cpp2::DirInfo> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).root_ref()); + case 2: + return f(1, static_cast(t).data_ref()); + default: + throwInvalidThriftId(id, "::nebula::cpp2::DirInfo"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::cpp2::NodeInfo> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).host_ref()); + case 2: + return f(1, static_cast(t).dir_ref()); + default: + throwInvalidThriftId(id, "::nebula::cpp2::NodeInfo"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::cpp2::PartitionBackupInfo> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).info_ref()); + default: + throwInvalidThriftId(id, "::nebula::cpp2::PartitionBackupInfo"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::cpp2::CheckpointInfo> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).partition_info_ref()); + case 2: + return f(1, static_cast(t).path_ref()); + default: + throwInvalidThriftId(id, "::nebula::cpp2::CheckpointInfo"); + } + } +}; +} // namespace detail +} // namespace thrift +} // namespace apache diff --git a/src/interface/gen-cpp2/common_visit_union.h b/src/interface/gen-cpp2/common_visit_union.h new file mode 100644 index 00000000..f3129c23 --- /dev/null +++ b/src/interface/gen-cpp2/common_visit_union.h @@ -0,0 +1,74 @@ +/** + * Autogenerated by Thrift for common.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#pragma once + +#include "common_metadata.h" +#include + +namespace apache { +namespace thrift { +namespace detail { + +template <> +struct VisitUnion<::nebula::cpp2::SchemaID> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, T&& t) const { + using Union = std::remove_reference_t; + switch (t.getType()) { + case Union::Type::tag_id: + return f(0, *static_cast(t).tag_id_ref()); + case Union::Type::edge_type: + return f(1, *static_cast(t).edge_type_ref()); + case Union::Type::__EMPTY__: ; + } + } +}; +template <> +struct VisitUnion<::nebula::cpp2::Value> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, T&& t) const { + using Union = std::remove_reference_t; + switch (t.getType()) { + case Union::Type::nVal: + return f(0, *static_cast(t).nVal_ref()); + case Union::Type::bVal: + return f(1, *static_cast(t).bVal_ref()); + case Union::Type::iVal: + return f(2, *static_cast(t).iVal_ref()); + case Union::Type::fVal: + return f(3, *static_cast(t).fVal_ref()); + case Union::Type::sVal: + return f(4, *static_cast(t).sVal_ref()); + case Union::Type::dVal: + return f(5, *static_cast(t).dVal_ref()); + case Union::Type::tVal: + return f(6, *static_cast(t).tVal_ref()); + case Union::Type::dtVal: + return f(7, *static_cast(t).dtVal_ref()); + case Union::Type::vVal: + return f(8, *static_cast(t).vVal_ref()); + case Union::Type::eVal: + return f(9, *static_cast(t).eVal_ref()); + case Union::Type::pVal: + return f(10, *static_cast(t).pVal_ref()); + case Union::Type::lVal: + return f(11, *static_cast(t).lVal_ref()); + case Union::Type::mVal: + return f(12, *static_cast(t).mVal_ref()); + case Union::Type::uVal: + return f(13, *static_cast(t).uVal_ref()); + case Union::Type::gVal: + return f(14, *static_cast(t).gVal_ref()); + case Union::Type::ggVal: + return f(15, *static_cast(t).ggVal_ref()); + case Union::Type::__EMPTY__: ; + } + } +}; +} // namespace detail +} // namespace thrift +} // namespace apache diff --git a/src/interface/gen-cpp2/common_visitation.h b/src/interface/gen-cpp2/common_visitation.h new file mode 100644 index 00000000..bb14a188 --- /dev/null +++ b/src/interface/gen-cpp2/common_visitation.h @@ -0,0 +1,9 @@ +/** + * Autogenerated by Thrift for common.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#pragma once +#include "common_for_each_field.h" +#include "common_visit_union.h" diff --git a/src/interface/gen-cpp2/graph_constants.cpp b/src/interface/gen-cpp2/graph_constants.cpp new file mode 100644 index 00000000..9f06d958 --- /dev/null +++ b/src/interface/gen-cpp2/graph_constants.cpp @@ -0,0 +1,6 @@ +/** + * Autogenerated by Thrift for graph.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ diff --git a/src/interface/gen-cpp2/graph_constants.h b/src/interface/gen-cpp2/graph_constants.h new file mode 100644 index 00000000..0263a1b3 --- /dev/null +++ b/src/interface/gen-cpp2/graph_constants.h @@ -0,0 +1,19 @@ +/** + * Autogenerated by Thrift for graph.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#pragma once + +#include + +#include "graph_types.h" + +namespace nebula { namespace graph { namespace cpp2 { + +struct graph_constants { + +}; + +}}} // nebula::graph::cpp2 diff --git a/src/interface/gen-cpp2/graph_data.cpp b/src/interface/gen-cpp2/graph_data.cpp new file mode 100644 index 00000000..cdfd30fc --- /dev/null +++ b/src/interface/gen-cpp2/graph_data.cpp @@ -0,0 +1,181 @@ +/** + * Autogenerated by Thrift for graph.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ + +#include "graph_data.h" + +#include + +namespace apache { +namespace thrift { + +const std::array TStructDataStorage<::nebula::graph::cpp2::ProfilingStats>::fields_names = {{ + "rows", + "exec_duration_in_us", + "total_duration_in_us", + "other_stats", +}}; +const std::array TStructDataStorage<::nebula::graph::cpp2::ProfilingStats>::fields_ids = {{ + 1, + 2, + 3, + 4, +}}; +const std::array TStructDataStorage<::nebula::graph::cpp2::ProfilingStats>::fields_types = {{ + TType::T_I64, + TType::T_I64, + TType::T_I64, + TType::T_MAP, +}}; + +const std::array TStructDataStorage<::nebula::graph::cpp2::PlanNodeBranchInfo>::fields_names = {{ + "is_do_branch", + "condition_node_id", +}}; +const std::array TStructDataStorage<::nebula::graph::cpp2::PlanNodeBranchInfo>::fields_ids = {{ + 1, + 2, +}}; +const std::array TStructDataStorage<::nebula::graph::cpp2::PlanNodeBranchInfo>::fields_types = {{ + TType::T_BOOL, + TType::T_I64, +}}; + +const std::array TStructDataStorage<::nebula::graph::cpp2::Pair>::fields_names = {{ + "key", + "value", +}}; +const std::array TStructDataStorage<::nebula::graph::cpp2::Pair>::fields_ids = {{ + 1, + 2, +}}; +const std::array TStructDataStorage<::nebula::graph::cpp2::Pair>::fields_types = {{ + TType::T_STRING, + TType::T_STRING, +}}; + +const std::array TStructDataStorage<::nebula::graph::cpp2::PlanNodeDescription>::fields_names = {{ + "name", + "id", + "output_var", + "description", + "profiles", + "branch_info", + "dependencies", +}}; +const std::array TStructDataStorage<::nebula::graph::cpp2::PlanNodeDescription>::fields_ids = {{ + 1, + 2, + 3, + 4, + 5, + 6, + 7, +}}; +const std::array TStructDataStorage<::nebula::graph::cpp2::PlanNodeDescription>::fields_types = {{ + TType::T_STRING, + TType::T_I64, + TType::T_STRING, + TType::T_LIST, + TType::T_LIST, + TType::T_STRUCT, + TType::T_LIST, +}}; + +const std::array TStructDataStorage<::nebula::graph::cpp2::PlanDescription>::fields_names = {{ + "plan_node_descs", + "node_index_map", + "format", + "optimize_time_in_us", +}}; +const std::array TStructDataStorage<::nebula::graph::cpp2::PlanDescription>::fields_ids = {{ + 1, + 2, + 3, + 4, +}}; +const std::array TStructDataStorage<::nebula::graph::cpp2::PlanDescription>::fields_types = {{ + TType::T_LIST, + TType::T_MAP, + TType::T_STRING, + TType::T_I32, +}}; + +const std::array TStructDataStorage<::nebula::graph::cpp2::ExecutionResponse>::fields_names = {{ + "error_code", + "latency_in_us", + "data", + "space_name", + "error_msg", + "plan_desc", + "comment", +}}; +const std::array TStructDataStorage<::nebula::graph::cpp2::ExecutionResponse>::fields_ids = {{ + 1, + 2, + 3, + 4, + 5, + 6, + 7, +}}; +const std::array TStructDataStorage<::nebula::graph::cpp2::ExecutionResponse>::fields_types = {{ + TType::T_I32, + TType::T_I32, + TType::T_STRUCT, + TType::T_STRING, + TType::T_STRING, + TType::T_STRUCT, + TType::T_STRING, +}}; + +const std::array TStructDataStorage<::nebula::graph::cpp2::AuthResponse>::fields_names = {{ + "error_code", + "error_msg", + "session_id", + "time_zone_offset_seconds", + "time_zone_name", +}}; +const std::array TStructDataStorage<::nebula::graph::cpp2::AuthResponse>::fields_ids = {{ + 1, + 2, + 3, + 4, + 5, +}}; +const std::array TStructDataStorage<::nebula::graph::cpp2::AuthResponse>::fields_types = {{ + TType::T_I32, + TType::T_STRING, + TType::T_I64, + TType::T_I32, + TType::T_STRING, +}}; + +const std::array TStructDataStorage<::nebula::graph::cpp2::VerifyClientVersionResp>::fields_names = {{ + "error_code", + "error_msg", +}}; +const std::array TStructDataStorage<::nebula::graph::cpp2::VerifyClientVersionResp>::fields_ids = {{ + 1, + 2, +}}; +const std::array TStructDataStorage<::nebula::graph::cpp2::VerifyClientVersionResp>::fields_types = {{ + TType::T_I32, + TType::T_STRING, +}}; + +const std::array TStructDataStorage<::nebula::graph::cpp2::VerifyClientVersionReq>::fields_names = {{ + "version", +}}; +const std::array TStructDataStorage<::nebula::graph::cpp2::VerifyClientVersionReq>::fields_ids = {{ + 1, +}}; +const std::array TStructDataStorage<::nebula::graph::cpp2::VerifyClientVersionReq>::fields_types = {{ + TType::T_STRING, +}}; + +} // namespace thrift +} // namespace apache diff --git a/src/interface/gen-cpp2/graph_data.h b/src/interface/gen-cpp2/graph_data.h new file mode 100644 index 00000000..67209228 --- /dev/null +++ b/src/interface/gen-cpp2/graph_data.h @@ -0,0 +1,78 @@ +/** + * Autogenerated by Thrift for graph.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#pragma once + +#include + +#include "graph_types.h" + +namespace apache { namespace thrift { + +template <> struct TStructDataStorage<::nebula::graph::cpp2::ProfilingStats> { + static constexpr const std::size_t fields_size = 4; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::graph::cpp2::PlanNodeBranchInfo> { + static constexpr const std::size_t fields_size = 2; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::graph::cpp2::Pair> { + static constexpr const std::size_t fields_size = 2; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::graph::cpp2::PlanNodeDescription> { + static constexpr const std::size_t fields_size = 7; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::graph::cpp2::PlanDescription> { + static constexpr const std::size_t fields_size = 4; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::graph::cpp2::ExecutionResponse> { + static constexpr const std::size_t fields_size = 7; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::graph::cpp2::AuthResponse> { + static constexpr const std::size_t fields_size = 5; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::graph::cpp2::VerifyClientVersionResp> { + static constexpr const std::size_t fields_size = 2; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::graph::cpp2::VerifyClientVersionReq> { + static constexpr const std::size_t fields_size = 1; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +}} // apache::thrift diff --git a/src/interface/gen-cpp2/graph_for_each_field.h b/src/interface/gen-cpp2/graph_for_each_field.h new file mode 100644 index 00000000..6cd74e3e --- /dev/null +++ b/src/interface/gen-cpp2/graph_for_each_field.h @@ -0,0 +1,114 @@ +/** + * Autogenerated by Thrift for graph.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#pragma once + +#include "graph_metadata.h" +#include + +namespace apache { +namespace thrift { +namespace detail { + +template <> +struct ForEachField<::nebula::graph::cpp2::ProfilingStats> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).rows_ref()...); + f(1, static_cast(t).exec_duration_in_us_ref()...); + f(2, static_cast(t).total_duration_in_us_ref()...); + f(3, static_cast(t).other_stats_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::graph::cpp2::PlanNodeBranchInfo> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).is_do_branch_ref()...); + f(1, static_cast(t).condition_node_id_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::graph::cpp2::Pair> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).key_ref()...); + f(1, static_cast(t).value_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::graph::cpp2::PlanNodeDescription> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).name_ref()...); + f(1, static_cast(t).id_ref()...); + f(2, static_cast(t).output_var_ref()...); + f(3, static_cast(t).description_ref()...); + f(4, static_cast(t).profiles_ref()...); + f(5, static_cast(t).branch_info_ref()...); + f(6, static_cast(t).dependencies_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::graph::cpp2::PlanDescription> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).plan_node_descs_ref()...); + f(1, static_cast(t).node_index_map_ref()...); + f(2, static_cast(t).format_ref()...); + f(3, static_cast(t).optimize_time_in_us_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::graph::cpp2::ExecutionResponse> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).error_code_ref()...); + f(1, static_cast(t).latency_in_us_ref()...); + f(2, static_cast(t).data_ref()...); + f(3, static_cast(t).space_name_ref()...); + f(4, static_cast(t).error_msg_ref()...); + f(5, static_cast(t).plan_desc_ref()...); + f(6, static_cast(t).comment_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::graph::cpp2::AuthResponse> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).error_code_ref()...); + f(1, static_cast(t).error_msg_ref()...); + f(2, static_cast(t).session_id_ref()...); + f(3, static_cast(t).time_zone_offset_seconds_ref()...); + f(4, static_cast(t).time_zone_name_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::graph::cpp2::VerifyClientVersionResp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).error_code_ref()...); + f(1, static_cast(t).error_msg_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::graph::cpp2::VerifyClientVersionReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).version_ref()...); + } +}; +} // namespace detail +} // namespace thrift +} // namespace apache diff --git a/src/interface/gen-cpp2/graph_metadata.cpp b/src/interface/gen-cpp2/graph_metadata.cpp new file mode 100644 index 00000000..910bdadb --- /dev/null +++ b/src/interface/gen-cpp2/graph_metadata.cpp @@ -0,0 +1,388 @@ +/** + * Autogenerated by Thrift for graph.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#include +#include "graph_metadata.h" + +namespace apache { +namespace thrift { +namespace detail { +namespace md { +using ThriftMetadata = ::apache::thrift::metadata::ThriftMetadata; +using ThriftPrimitiveType = ::apache::thrift::metadata::ThriftPrimitiveType; +using ThriftType = ::apache::thrift::metadata::ThriftType; +using ThriftService = ::apache::thrift::metadata::ThriftService; +using ThriftServiceContext = ::apache::thrift::metadata::ThriftServiceContext; +using ThriftFunctionGenerator = void (*)(ThriftMetadata&, ThriftService&); + + +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::graph::cpp2::ProfilingStats>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("graph.ProfilingStats", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& graph_ProfilingStats = res.first->second; + graph_ProfilingStats.name_ref() = "graph.ProfilingStats"; + graph_ProfilingStats.is_union_ref() = false; + static const EncodedThriftField + graph_ProfilingStats_fields[] = { + std::make_tuple(1, "rows", false, std::make_unique(ThriftPrimitiveType::THRIFT_I64_TYPE), std::vector{}), + std::make_tuple(2, "exec_duration_in_us", false, std::make_unique(ThriftPrimitiveType::THRIFT_I64_TYPE), std::vector{}), + std::make_tuple(3, "total_duration_in_us", false, std::make_unique(ThriftPrimitiveType::THRIFT_I64_TYPE), std::vector{}), + std::make_tuple(4, "other_stats", true, std::make_unique(std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE)), std::vector{}), + }; + for (const auto& f : graph_ProfilingStats_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + graph_ProfilingStats.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::graph::cpp2::PlanNodeBranchInfo>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("graph.PlanNodeBranchInfo", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& graph_PlanNodeBranchInfo = res.first->second; + graph_PlanNodeBranchInfo.name_ref() = "graph.PlanNodeBranchInfo"; + graph_PlanNodeBranchInfo.is_union_ref() = false; + static const EncodedThriftField + graph_PlanNodeBranchInfo_fields[] = { + std::make_tuple(1, "is_do_branch", false, std::make_unique(ThriftPrimitiveType::THRIFT_BOOL_TYPE), std::vector{}), + std::make_tuple(2, "condition_node_id", false, std::make_unique(ThriftPrimitiveType::THRIFT_I64_TYPE), std::vector{}), + }; + for (const auto& f : graph_PlanNodeBranchInfo_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + graph_PlanNodeBranchInfo.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::graph::cpp2::Pair>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("graph.Pair", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& graph_Pair = res.first->second; + graph_Pair.name_ref() = "graph.Pair"; + graph_Pair.is_union_ref() = false; + static const EncodedThriftField + graph_Pair_fields[] = { + std::make_tuple(1, "key", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + std::make_tuple(2, "value", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + }; + for (const auto& f : graph_Pair_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + graph_Pair.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::graph::cpp2::PlanNodeDescription>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("graph.PlanNodeDescription", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& graph_PlanNodeDescription = res.first->second; + graph_PlanNodeDescription.name_ref() = "graph.PlanNodeDescription"; + graph_PlanNodeDescription.is_union_ref() = false; + static const EncodedThriftField + graph_PlanNodeDescription_fields[] = { + std::make_tuple(1, "name", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + std::make_tuple(2, "id", false, std::make_unique(ThriftPrimitiveType::THRIFT_I64_TYPE), std::vector{}), + std::make_tuple(3, "output_var", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + std::make_tuple(4, "description", true, std::make_unique(std::make_unique>("graph.Pair")), std::vector{}), + std::make_tuple(5, "profiles", true, std::make_unique(std::make_unique>("graph.ProfilingStats")), std::vector{}), + std::make_tuple(6, "branch_info", true, std::make_unique>("graph.PlanNodeBranchInfo"), std::vector{}), + std::make_tuple(7, "dependencies", true, std::make_unique(std::make_unique(ThriftPrimitiveType::THRIFT_I64_TYPE)), std::vector{}), + }; + for (const auto& f : graph_PlanNodeDescription_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + graph_PlanNodeDescription.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::graph::cpp2::PlanDescription>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("graph.PlanDescription", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& graph_PlanDescription = res.first->second; + graph_PlanDescription.name_ref() = "graph.PlanDescription"; + graph_PlanDescription.is_union_ref() = false; + static const EncodedThriftField + graph_PlanDescription_fields[] = { + std::make_tuple(1, "plan_node_descs", false, std::make_unique(std::make_unique>("graph.PlanNodeDescription")), std::vector{}), + std::make_tuple(2, "node_index_map", false, std::make_unique(std::make_unique(ThriftPrimitiveType::THRIFT_I64_TYPE), std::make_unique(ThriftPrimitiveType::THRIFT_I64_TYPE)), std::vector{}), + std::make_tuple(3, "format", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + std::make_tuple(4, "optimize_time_in_us", false, std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE), std::vector{}), + }; + for (const auto& f : graph_PlanDescription_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + graph_PlanDescription.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::graph::cpp2::ExecutionResponse>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("graph.ExecutionResponse", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& graph_ExecutionResponse = res.first->second; + graph_ExecutionResponse.name_ref() = "graph.ExecutionResponse"; + graph_ExecutionResponse.is_union_ref() = false; + static const EncodedThriftField + graph_ExecutionResponse_fields[] = { + std::make_tuple(1, "error_code", false, std::make_unique>("common.ErrorCode"), std::vector{}), + std::make_tuple(2, "latency_in_us", false, std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE), std::vector{}), + std::make_tuple(3, "data", true, std::make_unique>("common.DataSet"), std::vector{}), + std::make_tuple(4, "space_name", true, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + std::make_tuple(5, "error_msg", true, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + std::make_tuple(6, "plan_desc", true, std::make_unique>("graph.PlanDescription"), std::vector{}), + std::make_tuple(7, "comment", true, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + }; + for (const auto& f : graph_ExecutionResponse_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + graph_ExecutionResponse.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::graph::cpp2::AuthResponse>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("graph.AuthResponse", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& graph_AuthResponse = res.first->second; + graph_AuthResponse.name_ref() = "graph.AuthResponse"; + graph_AuthResponse.is_union_ref() = false; + static const EncodedThriftField + graph_AuthResponse_fields[] = { + std::make_tuple(1, "error_code", false, std::make_unique>("common.ErrorCode"), std::vector{}), + std::make_tuple(2, "error_msg", true, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + std::make_tuple(3, "session_id", true, std::make_unique(ThriftPrimitiveType::THRIFT_I64_TYPE), std::vector{}), + std::make_tuple(4, "time_zone_offset_seconds", true, std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE), std::vector{}), + std::make_tuple(5, "time_zone_name", true, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + }; + for (const auto& f : graph_AuthResponse_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + graph_AuthResponse.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::graph::cpp2::VerifyClientVersionResp>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("graph.VerifyClientVersionResp", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& graph_VerifyClientVersionResp = res.first->second; + graph_VerifyClientVersionResp.name_ref() = "graph.VerifyClientVersionResp"; + graph_VerifyClientVersionResp.is_union_ref() = false; + static const EncodedThriftField + graph_VerifyClientVersionResp_fields[] = { + std::make_tuple(1, "error_code", false, std::make_unique>("common.ErrorCode"), std::vector{}), + std::make_tuple(2, "error_msg", true, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + }; + for (const auto& f : graph_VerifyClientVersionResp_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + graph_VerifyClientVersionResp.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::graph::cpp2::VerifyClientVersionReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("graph.VerifyClientVersionReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& graph_VerifyClientVersionReq = res.first->second; + graph_VerifyClientVersionReq.name_ref() = "graph.VerifyClientVersionReq"; + graph_VerifyClientVersionReq.is_union_ref() = false; + static const EncodedThriftField + graph_VerifyClientVersionReq_fields[] = { + std::make_tuple(1, "version", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + }; + for (const auto& f : graph_VerifyClientVersionReq_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + graph_VerifyClientVersionReq.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} + +void ServiceMetadata<::nebula::graph::cpp2::GraphServiceSvIf>::gen_authenticate(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "authenticate"; + auto func_ret_type = std::make_unique>("graph.AuthResponse"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField graph_GraphService_authenticate_username_1; + graph_GraphService_authenticate_username_1.id_ref() = 1; + graph_GraphService_authenticate_username_1.name_ref() = "username"; + graph_GraphService_authenticate_username_1.is_optional_ref() = false; + auto graph_GraphService_authenticate_username_1_type = std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE); + graph_GraphService_authenticate_username_1_type->writeAndGenType(*graph_GraphService_authenticate_username_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(graph_GraphService_authenticate_username_1)); + ::apache::thrift::metadata::ThriftField graph_GraphService_authenticate_password_2; + graph_GraphService_authenticate_password_2.id_ref() = 2; + graph_GraphService_authenticate_password_2.name_ref() = "password"; + graph_GraphService_authenticate_password_2.is_optional_ref() = false; + auto graph_GraphService_authenticate_password_2_type = std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE); + graph_GraphService_authenticate_password_2_type->writeAndGenType(*graph_GraphService_authenticate_password_2.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(graph_GraphService_authenticate_password_2)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::graph::cpp2::GraphServiceSvIf>::gen_signout(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "signout"; + auto func_ret_type = std::make_unique(ThriftPrimitiveType::THRIFT_VOID_TYPE); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField graph_GraphService_signout_sessionId_1; + graph_GraphService_signout_sessionId_1.id_ref() = 1; + graph_GraphService_signout_sessionId_1.name_ref() = "sessionId"; + graph_GraphService_signout_sessionId_1.is_optional_ref() = false; + auto graph_GraphService_signout_sessionId_1_type = std::make_unique(ThriftPrimitiveType::THRIFT_I64_TYPE); + graph_GraphService_signout_sessionId_1_type->writeAndGenType(*graph_GraphService_signout_sessionId_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(graph_GraphService_signout_sessionId_1)); + func.is_oneway_ref() = true; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::graph::cpp2::GraphServiceSvIf>::gen_execute(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "execute"; + auto func_ret_type = std::make_unique>("graph.ExecutionResponse"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField graph_GraphService_execute_sessionId_1; + graph_GraphService_execute_sessionId_1.id_ref() = 1; + graph_GraphService_execute_sessionId_1.name_ref() = "sessionId"; + graph_GraphService_execute_sessionId_1.is_optional_ref() = false; + auto graph_GraphService_execute_sessionId_1_type = std::make_unique(ThriftPrimitiveType::THRIFT_I64_TYPE); + graph_GraphService_execute_sessionId_1_type->writeAndGenType(*graph_GraphService_execute_sessionId_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(graph_GraphService_execute_sessionId_1)); + ::apache::thrift::metadata::ThriftField graph_GraphService_execute_stmt_2; + graph_GraphService_execute_stmt_2.id_ref() = 2; + graph_GraphService_execute_stmt_2.name_ref() = "stmt"; + graph_GraphService_execute_stmt_2.is_optional_ref() = false; + auto graph_GraphService_execute_stmt_2_type = std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE); + graph_GraphService_execute_stmt_2_type->writeAndGenType(*graph_GraphService_execute_stmt_2.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(graph_GraphService_execute_stmt_2)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::graph::cpp2::GraphServiceSvIf>::gen_executeJson(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "executeJson"; + auto func_ret_type = std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField graph_GraphService_executeJson_sessionId_1; + graph_GraphService_executeJson_sessionId_1.id_ref() = 1; + graph_GraphService_executeJson_sessionId_1.name_ref() = "sessionId"; + graph_GraphService_executeJson_sessionId_1.is_optional_ref() = false; + auto graph_GraphService_executeJson_sessionId_1_type = std::make_unique(ThriftPrimitiveType::THRIFT_I64_TYPE); + graph_GraphService_executeJson_sessionId_1_type->writeAndGenType(*graph_GraphService_executeJson_sessionId_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(graph_GraphService_executeJson_sessionId_1)); + ::apache::thrift::metadata::ThriftField graph_GraphService_executeJson_stmt_2; + graph_GraphService_executeJson_stmt_2.id_ref() = 2; + graph_GraphService_executeJson_stmt_2.name_ref() = "stmt"; + graph_GraphService_executeJson_stmt_2.is_optional_ref() = false; + auto graph_GraphService_executeJson_stmt_2_type = std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE); + graph_GraphService_executeJson_stmt_2_type->writeAndGenType(*graph_GraphService_executeJson_stmt_2.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(graph_GraphService_executeJson_stmt_2)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::graph::cpp2::GraphServiceSvIf>::gen_verifyClientVersion(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "verifyClientVersion"; + auto func_ret_type = std::make_unique>("graph.VerifyClientVersionResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField graph_GraphService_verifyClientVersion_req_1; + graph_GraphService_verifyClientVersion_req_1.id_ref() = 1; + graph_GraphService_verifyClientVersion_req_1.name_ref() = "req"; + graph_GraphService_verifyClientVersion_req_1.is_optional_ref() = false; + auto graph_GraphService_verifyClientVersion_req_1_type = std::make_unique>("graph.VerifyClientVersionReq"); + graph_GraphService_verifyClientVersion_req_1_type->writeAndGenType(*graph_GraphService_verifyClientVersion_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(graph_GraphService_verifyClientVersion_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} + +void ServiceMetadata<::nebula::graph::cpp2::GraphServiceSvIf>::gen(ThriftMetadata& metadata, ThriftServiceContext& context) { + (void) metadata; + ::apache::thrift::metadata::ThriftService graph_GraphService; + graph_GraphService.name_ref() = "graph.GraphService"; + static const ThriftFunctionGenerator functions[] = { + ServiceMetadata<::nebula::graph::cpp2::GraphServiceSvIf>::gen_authenticate, + ServiceMetadata<::nebula::graph::cpp2::GraphServiceSvIf>::gen_signout, + ServiceMetadata<::nebula::graph::cpp2::GraphServiceSvIf>::gen_execute, + ServiceMetadata<::nebula::graph::cpp2::GraphServiceSvIf>::gen_executeJson, + ServiceMetadata<::nebula::graph::cpp2::GraphServiceSvIf>::gen_verifyClientVersion, + }; + for (auto& function_gen : functions) { + function_gen(metadata, graph_GraphService); + } + context.service_info_ref() = std::move(graph_GraphService); + ::apache::thrift::metadata::ThriftModuleContext module; + module.name_ref() = "graph"; + context.module_ref() = std::move(module); +} +} // namespace md +} // namespace detail +} // namespace thrift +} // namespace apache diff --git a/src/interface/gen-cpp2/graph_metadata.h b/src/interface/gen-cpp2/graph_metadata.h new file mode 100644 index 00000000..c0166f55 --- /dev/null +++ b/src/interface/gen-cpp2/graph_metadata.h @@ -0,0 +1,83 @@ +/** + * Autogenerated by Thrift for graph.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#pragma once + +#include +#include "graph_types.h" +#include "common_metadata.h" + +namespace nebula { +namespace graph { +namespace cpp2 { +class GraphServiceSvIf; +}}} // namespace nebula::graph::cpp2 + +namespace apache { +namespace thrift { +namespace detail { +namespace md { + +template <> +class StructMetadata<::nebula::graph::cpp2::ProfilingStats> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::graph::cpp2::PlanNodeBranchInfo> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::graph::cpp2::Pair> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::graph::cpp2::PlanNodeDescription> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::graph::cpp2::PlanDescription> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::graph::cpp2::ExecutionResponse> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::graph::cpp2::AuthResponse> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::graph::cpp2::VerifyClientVersionResp> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::graph::cpp2::VerifyClientVersionReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class ServiceMetadata<::nebula::graph::cpp2::GraphServiceSvIf> { + public: + static void gen(ThriftMetadata& metadata, ThriftServiceContext& context); + private: + static void gen_authenticate(ThriftMetadata& metadata, ThriftService& context); + static void gen_signout(ThriftMetadata& metadata, ThriftService& context); + static void gen_execute(ThriftMetadata& metadata, ThriftService& context); + static void gen_executeJson(ThriftMetadata& metadata, ThriftService& context); + static void gen_verifyClientVersion(ThriftMetadata& metadata, ThriftService& context); +}; +} // namespace md +} // namespace detail +} // namespace thrift +} // namespace apache diff --git a/src/interface/gen-cpp2/graph_types.cpp b/src/interface/gen-cpp2/graph_types.cpp new file mode 100644 index 00000000..2077919a --- /dev/null +++ b/src/interface/gen-cpp2/graph_types.cpp @@ -0,0 +1,1049 @@ +/** + * Autogenerated by Thrift for graph.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#include "graph_types.h" +#include "graph_types.tcc" + +#include + +#include "graph_data.h" + + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::graph::cpp2::ProfilingStats>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::graph::cpp2::ProfilingStats>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace graph { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +ProfilingStats::ProfilingStats(apache::thrift::FragileConstructor, int64_t rows__arg, int64_t exec_duration_in_us__arg, int64_t total_duration_in_us__arg, std::unordered_map<::std::string, ::std::string> other_stats__arg) : + rows(std::move(rows__arg)), + exec_duration_in_us(std::move(exec_duration_in_us__arg)), + total_duration_in_us(std::move(total_duration_in_us__arg)), + other_stats(std::move(other_stats__arg)) { + __isset.other_stats = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void ProfilingStats::__clear() { + // clear all fields + rows = 0; + exec_duration_in_us = 0; + total_duration_in_us = 0; + other_stats.clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool ProfilingStats::operator==(const ProfilingStats& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.rows == rhs.rows)) { + return false; + } + if (!(lhs.exec_duration_in_us == rhs.exec_duration_in_us)) { + return false; + } + if (!(lhs.total_duration_in_us == rhs.total_duration_in_us)) { + return false; + } + if (lhs.other_stats_ref() != rhs.other_stats_ref()) { + return false; + } + return true; +} + +const std::unordered_map<::std::string, ::std::string>* ProfilingStats::get_other_stats() const& { + return other_stats_ref().has_value() ? std::addressof(other_stats) : nullptr; +} + +std::unordered_map<::std::string, ::std::string>* ProfilingStats::get_other_stats() & { + return other_stats_ref().has_value() ? std::addressof(other_stats) : nullptr; +} + + +void swap(ProfilingStats& a, ProfilingStats& b) { + using ::std::swap; + swap(a.rows_ref().value(), b.rows_ref().value()); + swap(a.exec_duration_in_us_ref().value(), b.exec_duration_in_us_ref().value()); + swap(a.total_duration_in_us_ref().value(), b.total_duration_in_us_ref().value()); + swap(a.other_stats_ref().value_unchecked(), b.other_stats_ref().value_unchecked()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void ProfilingStats::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t ProfilingStats::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t ProfilingStats::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t ProfilingStats::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void ProfilingStats::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t ProfilingStats::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t ProfilingStats::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t ProfilingStats::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::graph::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::graph::cpp2::PlanNodeBranchInfo>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::graph::cpp2::PlanNodeBranchInfo>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace graph { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +PlanNodeBranchInfo::PlanNodeBranchInfo(apache::thrift::FragileConstructor, bool is_do_branch__arg, int64_t condition_node_id__arg) : + is_do_branch(std::move(is_do_branch__arg)), + condition_node_id(std::move(condition_node_id__arg)) {} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void PlanNodeBranchInfo::__clear() { + // clear all fields + is_do_branch = 0; + condition_node_id = 0; +} + +bool PlanNodeBranchInfo::operator==(const PlanNodeBranchInfo& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.is_do_branch == rhs.is_do_branch)) { + return false; + } + if (!(lhs.condition_node_id == rhs.condition_node_id)) { + return false; + } + return true; +} + +bool PlanNodeBranchInfo::operator<(const PlanNodeBranchInfo& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.is_do_branch == rhs.is_do_branch)) { + return lhs.is_do_branch < rhs.is_do_branch; + } + if (!(lhs.condition_node_id == rhs.condition_node_id)) { + return lhs.condition_node_id < rhs.condition_node_id; + } + return false; +} + + +void swap(PlanNodeBranchInfo& a, PlanNodeBranchInfo& b) { + using ::std::swap; + swap(a.is_do_branch_ref().value(), b.is_do_branch_ref().value()); + swap(a.condition_node_id_ref().value(), b.condition_node_id_ref().value()); +} + +template void PlanNodeBranchInfo::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t PlanNodeBranchInfo::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t PlanNodeBranchInfo::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t PlanNodeBranchInfo::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void PlanNodeBranchInfo::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t PlanNodeBranchInfo::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t PlanNodeBranchInfo::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t PlanNodeBranchInfo::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::graph::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::graph::cpp2::Pair>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::graph::cpp2::Pair>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace graph { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +Pair::Pair(apache::thrift::FragileConstructor, ::std::string key__arg, ::std::string value__arg) : + key(std::move(key__arg)), + value(std::move(value__arg)) {} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void Pair::__clear() { + // clear all fields + key = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); + value = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); +} + +bool Pair::operator==(const Pair& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!apache::thrift::StringTraits::isEqual(lhs.key, rhs.key)) { + return false; + } + if (!apache::thrift::StringTraits::isEqual(lhs.value, rhs.value)) { + return false; + } + return true; +} + +bool Pair::operator<(const Pair& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!apache::thrift::StringTraits::isEqual(lhs.key, rhs.key)) { + return apache::thrift::StringTraits::isLess(lhs.key, rhs.key); + } + if (!apache::thrift::StringTraits::isEqual(lhs.value, rhs.value)) { + return apache::thrift::StringTraits::isLess(lhs.value, rhs.value); + } + return false; +} + + +void swap(Pair& a, Pair& b) { + using ::std::swap; + swap(a.key_ref().value(), b.key_ref().value()); + swap(a.value_ref().value(), b.value_ref().value()); +} + +template void Pair::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t Pair::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t Pair::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t Pair::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void Pair::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t Pair::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t Pair::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t Pair::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::graph::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::graph::cpp2::PlanNodeDescription>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::graph::cpp2::PlanNodeDescription>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace graph { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +PlanNodeDescription::PlanNodeDescription() : + id(0) {} +THRIFT_IGNORE_ISSET_USE_WARNING_END + + +PlanNodeDescription::~PlanNodeDescription() {} + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +PlanNodeDescription::PlanNodeDescription(apache::thrift::FragileConstructor, ::std::string name__arg, int64_t id__arg, ::std::string output_var__arg, ::std::vector description__arg, ::std::vector profiles__arg, nebula::PlanNodeBranchInfo branch_info__arg, ::std::vector dependencies__arg) : + name(std::move(name__arg)), + id(std::move(id__arg)), + output_var(std::move(output_var__arg)), + description(std::move(description__arg)), + profiles(std::move(profiles__arg)), + branch_info(std::move(branch_info__arg)), + dependencies(std::move(dependencies__arg)) { + __isset.description = true; + __isset.profiles = true; + __isset.branch_info = true; + __isset.dependencies = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void PlanNodeDescription::__clear() { + // clear all fields + name = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); + id = 0; + output_var = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); + description.clear(); + profiles.clear(); + branch_info.__clear(); + dependencies.clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool PlanNodeDescription::operator==(const PlanNodeDescription& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!apache::thrift::StringTraits::isEqual(lhs.name, rhs.name)) { + return false; + } + if (!(lhs.id == rhs.id)) { + return false; + } + if (!apache::thrift::StringTraits::isEqual(lhs.output_var, rhs.output_var)) { + return false; + } + if (lhs.description_ref() != rhs.description_ref()) { + return false; + } + if (lhs.profiles_ref() != rhs.profiles_ref()) { + return false; + } + if (lhs.branch_info_ref() != rhs.branch_info_ref()) { + return false; + } + if (lhs.dependencies_ref() != rhs.dependencies_ref()) { + return false; + } + return true; +} + +const ::std::vector* PlanNodeDescription::get_description() const& { + return description_ref().has_value() ? std::addressof(description) : nullptr; +} + +::std::vector* PlanNodeDescription::get_description() & { + return description_ref().has_value() ? std::addressof(description) : nullptr; +} + +const ::std::vector* PlanNodeDescription::get_profiles() const& { + return profiles_ref().has_value() ? std::addressof(profiles) : nullptr; +} + +::std::vector* PlanNodeDescription::get_profiles() & { + return profiles_ref().has_value() ? std::addressof(profiles) : nullptr; +} + +const nebula::PlanNodeBranchInfo* PlanNodeDescription::get_branch_info() const& { + return branch_info_ref().has_value() ? std::addressof(branch_info) : nullptr; +} + +nebula::PlanNodeBranchInfo* PlanNodeDescription::get_branch_info() & { + return branch_info_ref().has_value() ? std::addressof(branch_info) : nullptr; +} + +const ::std::vector* PlanNodeDescription::get_dependencies() const& { + return dependencies_ref().has_value() ? std::addressof(dependencies) : nullptr; +} + +::std::vector* PlanNodeDescription::get_dependencies() & { + return dependencies_ref().has_value() ? std::addressof(dependencies) : nullptr; +} + + +void swap(PlanNodeDescription& a, PlanNodeDescription& b) { + using ::std::swap; + swap(a.name_ref().value(), b.name_ref().value()); + swap(a.id_ref().value(), b.id_ref().value()); + swap(a.output_var_ref().value(), b.output_var_ref().value()); + swap(a.description_ref().value_unchecked(), b.description_ref().value_unchecked()); + swap(a.profiles_ref().value_unchecked(), b.profiles_ref().value_unchecked()); + swap(a.branch_info_ref().value_unchecked(), b.branch_info_ref().value_unchecked()); + swap(a.dependencies_ref().value_unchecked(), b.dependencies_ref().value_unchecked()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void PlanNodeDescription::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t PlanNodeDescription::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t PlanNodeDescription::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t PlanNodeDescription::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void PlanNodeDescription::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t PlanNodeDescription::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t PlanNodeDescription::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t PlanNodeDescription::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + PlanNodeDescription, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + PlanNodeDescription, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + PlanNodeDescription, + ::apache::thrift::type_class::structure, + nebula::PlanNodeBranchInfo>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + PlanNodeDescription, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + PlanNodeDescription, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + PlanNodeDescription, + ::apache::thrift::type_class::structure, + nebula::PlanNodeBranchInfo>, + "inconsistent use of nimble option"); + +}}} // nebula::graph::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::graph::cpp2::PlanDescription>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::graph::cpp2::PlanDescription>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace graph { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +PlanDescription::PlanDescription(apache::thrift::FragileConstructor, ::std::vector plan_node_descs__arg, std::unordered_map node_index_map__arg, ::std::string format__arg, int32_t optimize_time_in_us__arg) : + plan_node_descs(std::move(plan_node_descs__arg)), + node_index_map(std::move(node_index_map__arg)), + format(std::move(format__arg)), + optimize_time_in_us(std::move(optimize_time_in_us__arg)) {} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void PlanDescription::__clear() { + // clear all fields + plan_node_descs.clear(); + node_index_map.clear(); + format = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); + optimize_time_in_us = 0; +} + +bool PlanDescription::operator==(const PlanDescription& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.plan_node_descs == rhs.plan_node_descs)) { + return false; + } + if (!(lhs.node_index_map == rhs.node_index_map)) { + return false; + } + if (!apache::thrift::StringTraits::isEqual(lhs.format, rhs.format)) { + return false; + } + if (!(lhs.optimize_time_in_us == rhs.optimize_time_in_us)) { + return false; + } + return true; +} + +const ::std::vector& PlanDescription::get_plan_node_descs() const& { + return plan_node_descs; +} + +::std::vector PlanDescription::get_plan_node_descs() && { + return std::move(plan_node_descs); +} + +const std::unordered_map& PlanDescription::get_node_index_map() const& { + return node_index_map; +} + +std::unordered_map PlanDescription::get_node_index_map() && { + return std::move(node_index_map); +} + + +void swap(PlanDescription& a, PlanDescription& b) { + using ::std::swap; + swap(a.plan_node_descs_ref().value(), b.plan_node_descs_ref().value()); + swap(a.node_index_map_ref().value(), b.node_index_map_ref().value()); + swap(a.format_ref().value(), b.format_ref().value()); + swap(a.optimize_time_in_us_ref().value(), b.optimize_time_in_us_ref().value()); +} + +template void PlanDescription::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t PlanDescription::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t PlanDescription::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t PlanDescription::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void PlanDescription::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t PlanDescription::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t PlanDescription::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t PlanDescription::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + PlanDescription, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + PlanDescription, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector>, + "inconsistent use of nimble option"); + +}}} // nebula::graph::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::graph::cpp2::ExecutionResponse>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::graph::cpp2::ExecutionResponse>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace graph { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +ExecutionResponse::ExecutionResponse() : + error_code( ::nebula::cpp2::ErrorCode::SUCCEEDED), + latency_in_us(0) {} +THRIFT_IGNORE_ISSET_USE_WARNING_END + + +ExecutionResponse::~ExecutionResponse() {} + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +ExecutionResponse::ExecutionResponse(apache::thrift::FragileConstructor, ::nebula::cpp2::ErrorCode error_code__arg, int32_t latency_in_us__arg, nebula::DataSet data__arg, ::std::string space_name__arg, ::std::string error_msg__arg, nebula::PlanDescription plan_desc__arg, ::std::string comment__arg) : + error_code(std::move(error_code__arg)), + latency_in_us(std::move(latency_in_us__arg)), + data(std::move(data__arg)), + space_name(std::move(space_name__arg)), + error_msg(std::move(error_msg__arg)), + plan_desc(std::move(plan_desc__arg)), + comment(std::move(comment__arg)) { + __isset.data = true; + __isset.space_name = true; + __isset.error_msg = true; + __isset.plan_desc = true; + __isset.comment = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void ExecutionResponse::__clear() { + // clear all fields + error_code = ::nebula::cpp2::ErrorCode::SUCCEEDED; + latency_in_us = 0; + data.__clear(); + space_name = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); + error_msg = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); + plan_desc.__clear(); + comment = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool ExecutionResponse::operator==(const ExecutionResponse& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.error_code == rhs.error_code)) { + return false; + } + if (!(lhs.latency_in_us == rhs.latency_in_us)) { + return false; + } + if (lhs.data_ref() != rhs.data_ref()) { + return false; + } + if (lhs.space_name_ref().has_value() != rhs.space_name_ref().has_value()) { + return false; + } + if (lhs.space_name_ref().has_value()) { + if (!apache::thrift::StringTraits::isEqual(lhs.space_name, rhs.space_name)) { + return false; + } + } + if (lhs.error_msg_ref().has_value() != rhs.error_msg_ref().has_value()) { + return false; + } + if (lhs.error_msg_ref().has_value()) { + if (!apache::thrift::StringTraits::isEqual(lhs.error_msg, rhs.error_msg)) { + return false; + } + } + if (lhs.plan_desc_ref() != rhs.plan_desc_ref()) { + return false; + } + if (lhs.comment_ref().has_value() != rhs.comment_ref().has_value()) { + return false; + } + if (lhs.comment_ref().has_value()) { + if (!apache::thrift::StringTraits::isEqual(lhs.comment, rhs.comment)) { + return false; + } + } + return true; +} + +const nebula::DataSet* ExecutionResponse::get_data() const& { + return data_ref().has_value() ? std::addressof(data) : nullptr; +} + +nebula::DataSet* ExecutionResponse::get_data() & { + return data_ref().has_value() ? std::addressof(data) : nullptr; +} + +const nebula::PlanDescription* ExecutionResponse::get_plan_desc() const& { + return plan_desc_ref().has_value() ? std::addressof(plan_desc) : nullptr; +} + +nebula::PlanDescription* ExecutionResponse::get_plan_desc() & { + return plan_desc_ref().has_value() ? std::addressof(plan_desc) : nullptr; +} + + +void swap(ExecutionResponse& a, ExecutionResponse& b) { + using ::std::swap; + swap(a.error_code_ref().value(), b.error_code_ref().value()); + swap(a.latency_in_us_ref().value(), b.latency_in_us_ref().value()); + swap(a.data_ref().value_unchecked(), b.data_ref().value_unchecked()); + swap(a.space_name_ref().value_unchecked(), b.space_name_ref().value_unchecked()); + swap(a.error_msg_ref().value_unchecked(), b.error_msg_ref().value_unchecked()); + swap(a.plan_desc_ref().value_unchecked(), b.plan_desc_ref().value_unchecked()); + swap(a.comment_ref().value_unchecked(), b.comment_ref().value_unchecked()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void ExecutionResponse::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t ExecutionResponse::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t ExecutionResponse::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t ExecutionResponse::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void ExecutionResponse::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t ExecutionResponse::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t ExecutionResponse::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t ExecutionResponse::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + ExecutionResponse, + ::apache::thrift::type_class::structure, + nebula::DataSet>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + ExecutionResponse, + ::apache::thrift::type_class::structure, + nebula::PlanDescription>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + ExecutionResponse, + ::apache::thrift::type_class::structure, + nebula::DataSet>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + ExecutionResponse, + ::apache::thrift::type_class::structure, + nebula::PlanDescription>, + "inconsistent use of nimble option"); + +}}} // nebula::graph::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::graph::cpp2::AuthResponse>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::graph::cpp2::AuthResponse>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace graph { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +AuthResponse::AuthResponse() : + error_code( ::nebula::cpp2::ErrorCode::SUCCEEDED), + session_id(0), + time_zone_offset_seconds(0) {} +THRIFT_IGNORE_ISSET_USE_WARNING_END + + +AuthResponse::~AuthResponse() {} + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +AuthResponse::AuthResponse(apache::thrift::FragileConstructor, ::nebula::cpp2::ErrorCode error_code__arg, ::std::string error_msg__arg, int64_t session_id__arg, int32_t time_zone_offset_seconds__arg, ::std::string time_zone_name__arg) : + error_code(std::move(error_code__arg)), + error_msg(std::move(error_msg__arg)), + session_id(std::move(session_id__arg)), + time_zone_offset_seconds(std::move(time_zone_offset_seconds__arg)), + time_zone_name(std::move(time_zone_name__arg)) { + __isset.error_msg = true; + __isset.session_id = true; + __isset.time_zone_offset_seconds = true; + __isset.time_zone_name = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void AuthResponse::__clear() { + // clear all fields + error_code = ::nebula::cpp2::ErrorCode::SUCCEEDED; + error_msg = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); + session_id = 0; + time_zone_offset_seconds = 0; + time_zone_name = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool AuthResponse::operator==(const AuthResponse& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.error_code == rhs.error_code)) { + return false; + } + if (lhs.error_msg_ref().has_value() != rhs.error_msg_ref().has_value()) { + return false; + } + if (lhs.error_msg_ref().has_value()) { + if (!apache::thrift::StringTraits::isEqual(lhs.error_msg, rhs.error_msg)) { + return false; + } + } + if (lhs.session_id_ref() != rhs.session_id_ref()) { + return false; + } + if (lhs.time_zone_offset_seconds_ref() != rhs.time_zone_offset_seconds_ref()) { + return false; + } + if (lhs.time_zone_name_ref().has_value() != rhs.time_zone_name_ref().has_value()) { + return false; + } + if (lhs.time_zone_name_ref().has_value()) { + if (!apache::thrift::StringTraits::isEqual(lhs.time_zone_name, rhs.time_zone_name)) { + return false; + } + } + return true; +} + +bool AuthResponse::operator<(const AuthResponse& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.error_code == rhs.error_code)) { + return lhs.error_code < rhs.error_code; + } + if (lhs.error_msg_ref().has_value() != rhs.error_msg_ref().has_value()) { + return lhs.error_msg_ref().has_value() < rhs.error_msg_ref().has_value(); + } + if (lhs.error_msg_ref().has_value()) { + if (!apache::thrift::StringTraits::isEqual(lhs.error_msg, rhs.error_msg)) { + return apache::thrift::StringTraits::isLess(lhs.error_msg, rhs.error_msg); + } + } + if (lhs.session_id_ref() != rhs.session_id_ref()) { + return lhs.session_id_ref() < rhs.session_id_ref(); + } + if (lhs.time_zone_offset_seconds_ref() != rhs.time_zone_offset_seconds_ref()) { + return lhs.time_zone_offset_seconds_ref() < rhs.time_zone_offset_seconds_ref(); + } + if (lhs.time_zone_name_ref().has_value() != rhs.time_zone_name_ref().has_value()) { + return lhs.time_zone_name_ref().has_value() < rhs.time_zone_name_ref().has_value(); + } + if (lhs.time_zone_name_ref().has_value()) { + if (!apache::thrift::StringTraits::isEqual(lhs.time_zone_name, rhs.time_zone_name)) { + return apache::thrift::StringTraits::isLess(lhs.time_zone_name, rhs.time_zone_name); + } + } + return false; +} + + +void swap(AuthResponse& a, AuthResponse& b) { + using ::std::swap; + swap(a.error_code_ref().value(), b.error_code_ref().value()); + swap(a.error_msg_ref().value_unchecked(), b.error_msg_ref().value_unchecked()); + swap(a.session_id_ref().value_unchecked(), b.session_id_ref().value_unchecked()); + swap(a.time_zone_offset_seconds_ref().value_unchecked(), b.time_zone_offset_seconds_ref().value_unchecked()); + swap(a.time_zone_name_ref().value_unchecked(), b.time_zone_name_ref().value_unchecked()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void AuthResponse::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t AuthResponse::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t AuthResponse::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t AuthResponse::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void AuthResponse::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t AuthResponse::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t AuthResponse::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t AuthResponse::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::graph::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::graph::cpp2::VerifyClientVersionResp>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::graph::cpp2::VerifyClientVersionResp>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace graph { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +VerifyClientVersionResp::VerifyClientVersionResp(apache::thrift::FragileConstructor, ::nebula::cpp2::ErrorCode error_code__arg, ::std::string error_msg__arg) : + error_code(std::move(error_code__arg)), + error_msg(std::move(error_msg__arg)) { + __isset.error_msg = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void VerifyClientVersionResp::__clear() { + // clear all fields + error_code = ::nebula::cpp2::ErrorCode::SUCCEEDED; + error_msg = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool VerifyClientVersionResp::operator==(const VerifyClientVersionResp& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.error_code == rhs.error_code)) { + return false; + } + if (lhs.error_msg_ref().has_value() != rhs.error_msg_ref().has_value()) { + return false; + } + if (lhs.error_msg_ref().has_value()) { + if (!apache::thrift::StringTraits::isEqual(lhs.error_msg, rhs.error_msg)) { + return false; + } + } + return true; +} + +bool VerifyClientVersionResp::operator<(const VerifyClientVersionResp& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.error_code == rhs.error_code)) { + return lhs.error_code < rhs.error_code; + } + if (lhs.error_msg_ref().has_value() != rhs.error_msg_ref().has_value()) { + return lhs.error_msg_ref().has_value() < rhs.error_msg_ref().has_value(); + } + if (lhs.error_msg_ref().has_value()) { + if (!apache::thrift::StringTraits::isEqual(lhs.error_msg, rhs.error_msg)) { + return apache::thrift::StringTraits::isLess(lhs.error_msg, rhs.error_msg); + } + } + return false; +} + + +void swap(VerifyClientVersionResp& a, VerifyClientVersionResp& b) { + using ::std::swap; + swap(a.error_code_ref().value(), b.error_code_ref().value()); + swap(a.error_msg_ref().value_unchecked(), b.error_msg_ref().value_unchecked()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void VerifyClientVersionResp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t VerifyClientVersionResp::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t VerifyClientVersionResp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t VerifyClientVersionResp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void VerifyClientVersionResp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t VerifyClientVersionResp::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t VerifyClientVersionResp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t VerifyClientVersionResp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::graph::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::graph::cpp2::VerifyClientVersionReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::graph::cpp2::VerifyClientVersionReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace graph { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +VerifyClientVersionReq::VerifyClientVersionReq(apache::thrift::FragileConstructor, ::std::string version__arg) : + version(std::move(version__arg)) {} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void VerifyClientVersionReq::__clear() { + // clear all fields + version = apache::thrift::StringTraits< std::string>::fromStringLiteral("2.6.0"); +} + +bool VerifyClientVersionReq::operator==(const VerifyClientVersionReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!apache::thrift::StringTraits::isEqual(lhs.version, rhs.version)) { + return false; + } + return true; +} + +bool VerifyClientVersionReq::operator<(const VerifyClientVersionReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!apache::thrift::StringTraits::isEqual(lhs.version, rhs.version)) { + return apache::thrift::StringTraits::isLess(lhs.version, rhs.version); + } + return false; +} + + +void swap(VerifyClientVersionReq& a, VerifyClientVersionReq& b) { + using ::std::swap; + swap(a.version_ref().value(), b.version_ref().value()); +} + +template void VerifyClientVersionReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t VerifyClientVersionReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t VerifyClientVersionReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t VerifyClientVersionReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void VerifyClientVersionReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t VerifyClientVersionReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t VerifyClientVersionReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t VerifyClientVersionReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::graph::cpp2 diff --git a/src/interface/gen-cpp2/graph_types.h b/src/interface/gen-cpp2/graph_types.h new file mode 100644 index 00000000..9282286a --- /dev/null +++ b/src/interface/gen-cpp2/graph_types.h @@ -0,0 +1,2174 @@ +/** + * Autogenerated by Thrift for graph.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#pragma once + +#include + + +#include "common_types.h" +#include "common/graph/PairOps-inl.h" +#include "common/graph/ProfilingStatsOps-inl.h" +#include "common/graph/PlanNodeBranchInfoOps-inl.h" +#include "common/graph/PlanNodeDescriptionOps-inl.h" +#include "common/graph/PlanDescriptionOps-inl.h" +#include "common/graph/ExecutionResponseOps-inl.h" +#include "common/graph/AuthResponseOps-inl.h" + +namespace apache { +namespace thrift { +namespace tag { +struct rows; +struct exec_duration_in_us; +struct total_duration_in_us; +struct other_stats; +struct is_do_branch; +struct condition_node_id; +struct key; +struct value; +struct name; +struct id; +struct output_var; +struct description; +struct profiles; +struct branch_info; +struct dependencies; +struct plan_node_descs; +struct node_index_map; +struct format; +struct optimize_time_in_us; +struct error_code; +struct latency_in_us; +struct data; +struct space_name; +struct error_msg; +struct plan_desc; +struct comment; +struct error_code; +struct error_msg; +struct session_id; +struct time_zone_offset_seconds; +struct time_zone_name; +struct error_code; +struct error_msg; +struct version; +} // namespace tag +namespace detail { +#ifndef APACHE_THRIFT_ACCESSOR_rows +#define APACHE_THRIFT_ACCESSOR_rows +APACHE_THRIFT_DEFINE_ACCESSOR(rows); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_exec_duration_in_us +#define APACHE_THRIFT_ACCESSOR_exec_duration_in_us +APACHE_THRIFT_DEFINE_ACCESSOR(exec_duration_in_us); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_total_duration_in_us +#define APACHE_THRIFT_ACCESSOR_total_duration_in_us +APACHE_THRIFT_DEFINE_ACCESSOR(total_duration_in_us); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_other_stats +#define APACHE_THRIFT_ACCESSOR_other_stats +APACHE_THRIFT_DEFINE_ACCESSOR(other_stats); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_is_do_branch +#define APACHE_THRIFT_ACCESSOR_is_do_branch +APACHE_THRIFT_DEFINE_ACCESSOR(is_do_branch); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_condition_node_id +#define APACHE_THRIFT_ACCESSOR_condition_node_id +APACHE_THRIFT_DEFINE_ACCESSOR(condition_node_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_key +#define APACHE_THRIFT_ACCESSOR_key +APACHE_THRIFT_DEFINE_ACCESSOR(key); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_value +#define APACHE_THRIFT_ACCESSOR_value +APACHE_THRIFT_DEFINE_ACCESSOR(value); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_name +#define APACHE_THRIFT_ACCESSOR_name +APACHE_THRIFT_DEFINE_ACCESSOR(name); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_id +#define APACHE_THRIFT_ACCESSOR_id +APACHE_THRIFT_DEFINE_ACCESSOR(id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_output_var +#define APACHE_THRIFT_ACCESSOR_output_var +APACHE_THRIFT_DEFINE_ACCESSOR(output_var); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_description +#define APACHE_THRIFT_ACCESSOR_description +APACHE_THRIFT_DEFINE_ACCESSOR(description); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_profiles +#define APACHE_THRIFT_ACCESSOR_profiles +APACHE_THRIFT_DEFINE_ACCESSOR(profiles); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_branch_info +#define APACHE_THRIFT_ACCESSOR_branch_info +APACHE_THRIFT_DEFINE_ACCESSOR(branch_info); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_dependencies +#define APACHE_THRIFT_ACCESSOR_dependencies +APACHE_THRIFT_DEFINE_ACCESSOR(dependencies); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_plan_node_descs +#define APACHE_THRIFT_ACCESSOR_plan_node_descs +APACHE_THRIFT_DEFINE_ACCESSOR(plan_node_descs); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_node_index_map +#define APACHE_THRIFT_ACCESSOR_node_index_map +APACHE_THRIFT_DEFINE_ACCESSOR(node_index_map); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_format +#define APACHE_THRIFT_ACCESSOR_format +APACHE_THRIFT_DEFINE_ACCESSOR(format); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_optimize_time_in_us +#define APACHE_THRIFT_ACCESSOR_optimize_time_in_us +APACHE_THRIFT_DEFINE_ACCESSOR(optimize_time_in_us); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_error_code +#define APACHE_THRIFT_ACCESSOR_error_code +APACHE_THRIFT_DEFINE_ACCESSOR(error_code); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_latency_in_us +#define APACHE_THRIFT_ACCESSOR_latency_in_us +APACHE_THRIFT_DEFINE_ACCESSOR(latency_in_us); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_data +#define APACHE_THRIFT_ACCESSOR_data +APACHE_THRIFT_DEFINE_ACCESSOR(data); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_space_name +#define APACHE_THRIFT_ACCESSOR_space_name +APACHE_THRIFT_DEFINE_ACCESSOR(space_name); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_error_msg +#define APACHE_THRIFT_ACCESSOR_error_msg +APACHE_THRIFT_DEFINE_ACCESSOR(error_msg); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_plan_desc +#define APACHE_THRIFT_ACCESSOR_plan_desc +APACHE_THRIFT_DEFINE_ACCESSOR(plan_desc); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_comment +#define APACHE_THRIFT_ACCESSOR_comment +APACHE_THRIFT_DEFINE_ACCESSOR(comment); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_error_code +#define APACHE_THRIFT_ACCESSOR_error_code +APACHE_THRIFT_DEFINE_ACCESSOR(error_code); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_error_msg +#define APACHE_THRIFT_ACCESSOR_error_msg +APACHE_THRIFT_DEFINE_ACCESSOR(error_msg); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_session_id +#define APACHE_THRIFT_ACCESSOR_session_id +APACHE_THRIFT_DEFINE_ACCESSOR(session_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_time_zone_offset_seconds +#define APACHE_THRIFT_ACCESSOR_time_zone_offset_seconds +APACHE_THRIFT_DEFINE_ACCESSOR(time_zone_offset_seconds); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_time_zone_name +#define APACHE_THRIFT_ACCESSOR_time_zone_name +APACHE_THRIFT_DEFINE_ACCESSOR(time_zone_name); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_error_code +#define APACHE_THRIFT_ACCESSOR_error_code +APACHE_THRIFT_DEFINE_ACCESSOR(error_code); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_error_msg +#define APACHE_THRIFT_ACCESSOR_error_msg +APACHE_THRIFT_DEFINE_ACCESSOR(error_msg); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_version +#define APACHE_THRIFT_ACCESSOR_version +APACHE_THRIFT_DEFINE_ACCESSOR(version); +#endif +} // namespace detail +} // namespace thrift +} // namespace apache + +// BEGIN declare_enums + +// END declare_enums +// BEGIN forward_declare +namespace nebula { namespace graph { namespace cpp2 { +class ProfilingStats; +class PlanNodeBranchInfo; +class Pair; +class PlanNodeDescription; +class PlanDescription; +class ExecutionResponse; +class AuthResponse; +class VerifyClientVersionResp; +class VerifyClientVersionReq; +}}} // nebula::graph::cpp2 +// END forward_declare +// BEGIN typedefs + +// END typedefs +// BEGIN hash_and_equal_to +// END hash_and_equal_to +namespace nebula { namespace graph { namespace cpp2 { +class ProfilingStats final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = ProfilingStats; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + ProfilingStats() : + rows(0), + exec_duration_in_us(0), + total_duration_in_us(0) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + ProfilingStats(apache::thrift::FragileConstructor, int64_t rows__arg, int64_t exec_duration_in_us__arg, int64_t total_duration_in_us__arg, std::unordered_map<::std::string, ::std::string> other_stats__arg); + + ProfilingStats(ProfilingStats&&) = default; + + ProfilingStats(const ProfilingStats&) = default; + + + ProfilingStats& operator=(ProfilingStats&&) = default; + + ProfilingStats& operator=(const ProfilingStats&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + public: + int64_t rows; + public: + int64_t exec_duration_in_us; + public: + int64_t total_duration_in_us; + private: + std::unordered_map<::std::string, ::std::string> other_stats; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool other_stats; + } __isset = {}; + bool operator==(const ProfilingStats& rhs) const; +#ifndef SWIG + friend bool operator!=(const ProfilingStats& __x, const ProfilingStats& __y) { + return !(__x == __y); + } +#endif + bool operator<(const ProfilingStats& rhs) const; +#ifndef SWIG + friend bool operator>(const ProfilingStats& __x, const ProfilingStats& __y) { + return __y < __x; + } + friend bool operator<=(const ProfilingStats& __x, const ProfilingStats& __y) { + return !(__y < __x); + } + friend bool operator>=(const ProfilingStats& __x, const ProfilingStats& __y) { + return !(__x < __y); + } +#endif + template + FOLLY_ERASE ::apache::thrift::required_field_ref rows_ref() const& { + return ::apache::thrift::required_field_ref{this->rows}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref rows_ref() const&& { + return ::apache::thrift::required_field_ref{std::move(this->rows)}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref rows_ref() & { + return ::apache::thrift::required_field_ref{this->rows}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref rows_ref() && { + return ::apache::thrift::required_field_ref{std::move(this->rows)}; + } + template + FOLLY_ERASE ::apache::thrift::required_field_ref exec_duration_in_us_ref() const& { + return ::apache::thrift::required_field_ref{this->exec_duration_in_us}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref exec_duration_in_us_ref() const&& { + return ::apache::thrift::required_field_ref{std::move(this->exec_duration_in_us)}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref exec_duration_in_us_ref() & { + return ::apache::thrift::required_field_ref{this->exec_duration_in_us}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref exec_duration_in_us_ref() && { + return ::apache::thrift::required_field_ref{std::move(this->exec_duration_in_us)}; + } + template + FOLLY_ERASE ::apache::thrift::required_field_ref total_duration_in_us_ref() const& { + return ::apache::thrift::required_field_ref{this->total_duration_in_us}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref total_duration_in_us_ref() const&& { + return ::apache::thrift::required_field_ref{std::move(this->total_duration_in_us)}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref total_duration_in_us_ref() & { + return ::apache::thrift::required_field_ref{this->total_duration_in_us}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref total_duration_in_us_ref() && { + return ::apache::thrift::required_field_ref{std::move(this->total_duration_in_us)}; + } + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::optional_field_ref other_stats_ref() const& { + return {this->other_stats, __isset.other_stats}; + } + + template > + FOLLY_ERASE ::apache::thrift::optional_field_ref other_stats_ref() const&& { + return {std::move(this->other_stats), __isset.other_stats}; + } + + template > + FOLLY_ERASE ::apache::thrift::optional_field_ref other_stats_ref() & { + return {this->other_stats, __isset.other_stats}; + } + + template > + FOLLY_ERASE ::apache::thrift::optional_field_ref other_stats_ref() && { + return {std::move(this->other_stats), __isset.other_stats}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + int64_t get_rows() const { + return rows; + } + + int64_t& set_rows(int64_t rows_) { + rows = rows_; + return rows; + } + + int64_t get_exec_duration_in_us() const { + return exec_duration_in_us; + } + + int64_t& set_exec_duration_in_us(int64_t exec_duration_in_us_) { + exec_duration_in_us = exec_duration_in_us_; + return exec_duration_in_us; + } + + int64_t get_total_duration_in_us() const { + return total_duration_in_us; + } + + int64_t& set_total_duration_in_us(int64_t total_duration_in_us_) { + total_duration_in_us = total_duration_in_us_; + return total_duration_in_us; + } + const std::unordered_map<::std::string, ::std::string>* get_other_stats() const&; + std::unordered_map<::std::string, ::std::string>* get_other_stats() &; + std::unordered_map<::std::string, ::std::string>* get_other_stats() && = delete; + + template > + std::unordered_map<::std::string, ::std::string>& set_other_stats(T_ProfilingStats_other_stats_struct_setter&& other_stats_) { + other_stats = std::forward(other_stats_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.other_stats = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return other_stats; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< ProfilingStats >; + friend void swap(ProfilingStats& a, ProfilingStats& b); +}; + +template +uint32_t ProfilingStats::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::graph::cpp2 +namespace nebula { namespace graph { namespace cpp2 { +class PlanNodeBranchInfo final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = PlanNodeBranchInfo; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + PlanNodeBranchInfo() : + is_do_branch(0), + condition_node_id(0) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + PlanNodeBranchInfo(apache::thrift::FragileConstructor, bool is_do_branch__arg, int64_t condition_node_id__arg); + + PlanNodeBranchInfo(PlanNodeBranchInfo&&) = default; + + PlanNodeBranchInfo(const PlanNodeBranchInfo&) = default; + + + PlanNodeBranchInfo& operator=(PlanNodeBranchInfo&&) = default; + + PlanNodeBranchInfo& operator=(const PlanNodeBranchInfo&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + public: + bool is_do_branch; + public: + int64_t condition_node_id; + + public: + bool operator==(const PlanNodeBranchInfo& rhs) const; +#ifndef SWIG + friend bool operator!=(const PlanNodeBranchInfo& __x, const PlanNodeBranchInfo& __y) { + return !(__x == __y); + } +#endif + bool operator<(const PlanNodeBranchInfo& rhs) const; +#ifndef SWIG + friend bool operator>(const PlanNodeBranchInfo& __x, const PlanNodeBranchInfo& __y) { + return __y < __x; + } + friend bool operator<=(const PlanNodeBranchInfo& __x, const PlanNodeBranchInfo& __y) { + return !(__y < __x); + } + friend bool operator>=(const PlanNodeBranchInfo& __x, const PlanNodeBranchInfo& __y) { + return !(__x < __y); + } +#endif + template + FOLLY_ERASE ::apache::thrift::required_field_ref is_do_branch_ref() const& { + return ::apache::thrift::required_field_ref{this->is_do_branch}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref is_do_branch_ref() const&& { + return ::apache::thrift::required_field_ref{std::move(this->is_do_branch)}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref is_do_branch_ref() & { + return ::apache::thrift::required_field_ref{this->is_do_branch}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref is_do_branch_ref() && { + return ::apache::thrift::required_field_ref{std::move(this->is_do_branch)}; + } + template + FOLLY_ERASE ::apache::thrift::required_field_ref condition_node_id_ref() const& { + return ::apache::thrift::required_field_ref{this->condition_node_id}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref condition_node_id_ref() const&& { + return ::apache::thrift::required_field_ref{std::move(this->condition_node_id)}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref condition_node_id_ref() & { + return ::apache::thrift::required_field_ref{this->condition_node_id}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref condition_node_id_ref() && { + return ::apache::thrift::required_field_ref{std::move(this->condition_node_id)}; + } + + bool get_is_do_branch() const { + return is_do_branch; + } + + bool& set_is_do_branch(bool is_do_branch_) { + is_do_branch = is_do_branch_; + return is_do_branch; + } + + int64_t get_condition_node_id() const { + return condition_node_id; + } + + int64_t& set_condition_node_id(int64_t condition_node_id_) { + condition_node_id = condition_node_id_; + return condition_node_id; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< PlanNodeBranchInfo >; + friend void swap(PlanNodeBranchInfo& a, PlanNodeBranchInfo& b); +}; + +template +uint32_t PlanNodeBranchInfo::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::graph::cpp2 +namespace nebula { namespace graph { namespace cpp2 { +class Pair final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = Pair; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + Pair() {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + Pair(apache::thrift::FragileConstructor, ::std::string key__arg, ::std::string value__arg); + + Pair(Pair&&) = default; + + Pair(const Pair&) = default; + + + Pair& operator=(Pair&&) = default; + + Pair& operator=(const Pair&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + public: + ::std::string key; + public: + ::std::string value; + + public: + bool operator==(const Pair& rhs) const; +#ifndef SWIG + friend bool operator!=(const Pair& __x, const Pair& __y) { + return !(__x == __y); + } +#endif + bool operator<(const Pair& rhs) const; +#ifndef SWIG + friend bool operator>(const Pair& __x, const Pair& __y) { + return __y < __x; + } + friend bool operator<=(const Pair& __x, const Pair& __y) { + return !(__y < __x); + } + friend bool operator>=(const Pair& __x, const Pair& __y) { + return !(__x < __y); + } +#endif + template + FOLLY_ERASE ::apache::thrift::required_field_ref key_ref() const& { + return ::apache::thrift::required_field_ref{this->key}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref key_ref() const&& { + return ::apache::thrift::required_field_ref{std::move(this->key)}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref key_ref() & { + return ::apache::thrift::required_field_ref{this->key}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref key_ref() && { + return ::apache::thrift::required_field_ref{std::move(this->key)}; + } + template + FOLLY_ERASE ::apache::thrift::required_field_ref value_ref() const& { + return ::apache::thrift::required_field_ref{this->value}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref value_ref() const&& { + return ::apache::thrift::required_field_ref{std::move(this->value)}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref value_ref() & { + return ::apache::thrift::required_field_ref{this->value}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref value_ref() && { + return ::apache::thrift::required_field_ref{std::move(this->value)}; + } + + const ::std::string& get_key() const& { + return key; + } + + ::std::string get_key() && { + return std::move(key); + } + + template + ::std::string& set_key(T_Pair_key_struct_setter&& key_) { + key = std::forward(key_); + return key; + } + + const ::std::string& get_value() const& { + return value; + } + + ::std::string get_value() && { + return std::move(value); + } + + template + ::std::string& set_value(T_Pair_value_struct_setter&& value_) { + value = std::forward(value_); + return value; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< Pair >; + friend void swap(Pair& a, Pair& b); +}; + +template +uint32_t Pair::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::graph::cpp2 +namespace nebula { namespace graph { namespace cpp2 { +class PlanNodeDescription final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = PlanNodeDescription; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + + PlanNodeDescription(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + PlanNodeDescription(apache::thrift::FragileConstructor, ::std::string name__arg, int64_t id__arg, ::std::string output_var__arg, ::std::vector description__arg, ::std::vector profiles__arg, nebula::PlanNodeBranchInfo branch_info__arg, ::std::vector dependencies__arg); + + PlanNodeDescription(PlanNodeDescription&&) = default; + + PlanNodeDescription(const PlanNodeDescription&) = default; + + + PlanNodeDescription& operator=(PlanNodeDescription&&) = default; + + PlanNodeDescription& operator=(const PlanNodeDescription&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + + ~PlanNodeDescription(); + + public: + ::std::string name; + public: + int64_t id; + public: + ::std::string output_var; + private: + ::std::vector description; + private: + ::std::vector profiles; + private: + nebula::PlanNodeBranchInfo branch_info; + private: + ::std::vector dependencies; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool description; + bool profiles; + bool branch_info; + bool dependencies; + } __isset = {}; + bool operator==(const PlanNodeDescription& rhs) const; +#ifndef SWIG + friend bool operator!=(const PlanNodeDescription& __x, const PlanNodeDescription& __y) { + return !(__x == __y); + } +#endif + bool operator<(const PlanNodeDescription& rhs) const; +#ifndef SWIG + friend bool operator>(const PlanNodeDescription& __x, const PlanNodeDescription& __y) { + return __y < __x; + } + friend bool operator<=(const PlanNodeDescription& __x, const PlanNodeDescription& __y) { + return !(__y < __x); + } + friend bool operator>=(const PlanNodeDescription& __x, const PlanNodeDescription& __y) { + return !(__x < __y); + } +#endif + template + FOLLY_ERASE ::apache::thrift::required_field_ref name_ref() const& { + return ::apache::thrift::required_field_ref{this->name}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref name_ref() const&& { + return ::apache::thrift::required_field_ref{std::move(this->name)}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref name_ref() & { + return ::apache::thrift::required_field_ref{this->name}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref name_ref() && { + return ::apache::thrift::required_field_ref{std::move(this->name)}; + } + template + FOLLY_ERASE ::apache::thrift::required_field_ref id_ref() const& { + return ::apache::thrift::required_field_ref{this->id}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref id_ref() const&& { + return ::apache::thrift::required_field_ref{std::move(this->id)}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref id_ref() & { + return ::apache::thrift::required_field_ref{this->id}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref id_ref() && { + return ::apache::thrift::required_field_ref{std::move(this->id)}; + } + template + FOLLY_ERASE ::apache::thrift::required_field_ref output_var_ref() const& { + return ::apache::thrift::required_field_ref{this->output_var}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref output_var_ref() const&& { + return ::apache::thrift::required_field_ref{std::move(this->output_var)}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref output_var_ref() & { + return ::apache::thrift::required_field_ref{this->output_var}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref output_var_ref() && { + return ::apache::thrift::required_field_ref{std::move(this->output_var)}; + } + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::optional_field_ref description_ref() const& { + return {this->description, __isset.description}; + } + + template > + FOLLY_ERASE ::apache::thrift::optional_field_ref description_ref() const&& { + return {std::move(this->description), __isset.description}; + } + + template > + FOLLY_ERASE ::apache::thrift::optional_field_ref description_ref() & { + return {this->description, __isset.description}; + } + + template > + FOLLY_ERASE ::apache::thrift::optional_field_ref description_ref() && { + return {std::move(this->description), __isset.description}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::optional_field_ref profiles_ref() const& { + return {this->profiles, __isset.profiles}; + } + + template > + FOLLY_ERASE ::apache::thrift::optional_field_ref profiles_ref() const&& { + return {std::move(this->profiles), __isset.profiles}; + } + + template > + FOLLY_ERASE ::apache::thrift::optional_field_ref profiles_ref() & { + return {this->profiles, __isset.profiles}; + } + + template > + FOLLY_ERASE ::apache::thrift::optional_field_ref profiles_ref() && { + return {std::move(this->profiles), __isset.profiles}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::optional_field_ref branch_info_ref() const& { + return {this->branch_info, __isset.branch_info}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref branch_info_ref() const&& { + return {std::move(this->branch_info), __isset.branch_info}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref branch_info_ref() & { + return {this->branch_info, __isset.branch_info}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref branch_info_ref() && { + return {std::move(this->branch_info), __isset.branch_info}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::optional_field_ref dependencies_ref() const& { + return {this->dependencies, __isset.dependencies}; + } + + template > + FOLLY_ERASE ::apache::thrift::optional_field_ref dependencies_ref() const&& { + return {std::move(this->dependencies), __isset.dependencies}; + } + + template > + FOLLY_ERASE ::apache::thrift::optional_field_ref dependencies_ref() & { + return {this->dependencies, __isset.dependencies}; + } + + template > + FOLLY_ERASE ::apache::thrift::optional_field_ref dependencies_ref() && { + return {std::move(this->dependencies), __isset.dependencies}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + const ::std::string& get_name() const& { + return name; + } + + ::std::string get_name() && { + return std::move(name); + } + + template + ::std::string& set_name(T_PlanNodeDescription_name_struct_setter&& name_) { + name = std::forward(name_); + return name; + } + + int64_t get_id() const { + return id; + } + + int64_t& set_id(int64_t id_) { + id = id_; + return id; + } + + const ::std::string& get_output_var() const& { + return output_var; + } + + ::std::string get_output_var() && { + return std::move(output_var); + } + + template + ::std::string& set_output_var(T_PlanNodeDescription_output_var_struct_setter&& output_var_) { + output_var = std::forward(output_var_); + return output_var; + } + const ::std::vector* get_description() const&; + ::std::vector* get_description() &; + ::std::vector* get_description() && = delete; + + template > + ::std::vector& set_description(T_PlanNodeDescription_description_struct_setter&& description_) { + description = std::forward(description_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.description = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return description; + } + const ::std::vector* get_profiles() const&; + ::std::vector* get_profiles() &; + ::std::vector* get_profiles() && = delete; + + template > + ::std::vector& set_profiles(T_PlanNodeDescription_profiles_struct_setter&& profiles_) { + profiles = std::forward(profiles_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.profiles = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return profiles; + } + const nebula::PlanNodeBranchInfo* get_branch_info() const&; + nebula::PlanNodeBranchInfo* get_branch_info() &; + nebula::PlanNodeBranchInfo* get_branch_info() && = delete; + + template + nebula::PlanNodeBranchInfo& set_branch_info(T_PlanNodeDescription_branch_info_struct_setter&& branch_info_) { + branch_info = std::forward(branch_info_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.branch_info = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return branch_info; + } + const ::std::vector* get_dependencies() const&; + ::std::vector* get_dependencies() &; + ::std::vector* get_dependencies() && = delete; + + template > + ::std::vector& set_dependencies(T_PlanNodeDescription_dependencies_struct_setter&& dependencies_) { + dependencies = std::forward(dependencies_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.dependencies = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return dependencies; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< PlanNodeDescription >; + friend void swap(PlanNodeDescription& a, PlanNodeDescription& b); +}; + +template +uint32_t PlanNodeDescription::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::graph::cpp2 +namespace nebula { namespace graph { namespace cpp2 { +class PlanDescription final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = PlanDescription; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + PlanDescription() : + optimize_time_in_us(0) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + PlanDescription(apache::thrift::FragileConstructor, ::std::vector plan_node_descs__arg, std::unordered_map node_index_map__arg, ::std::string format__arg, int32_t optimize_time_in_us__arg); + + PlanDescription(PlanDescription&&) = default; + + PlanDescription(const PlanDescription&) = default; + + + PlanDescription& operator=(PlanDescription&&) = default; + + PlanDescription& operator=(const PlanDescription&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + public: + ::std::vector plan_node_descs; + public: + std::unordered_map node_index_map; + public: + ::std::string format; + public: + int32_t optimize_time_in_us; + + public: + bool operator==(const PlanDescription& rhs) const; +#ifndef SWIG + friend bool operator!=(const PlanDescription& __x, const PlanDescription& __y) { + return !(__x == __y); + } +#endif + bool operator<(const PlanDescription& rhs) const; +#ifndef SWIG + friend bool operator>(const PlanDescription& __x, const PlanDescription& __y) { + return __y < __x; + } + friend bool operator<=(const PlanDescription& __x, const PlanDescription& __y) { + return !(__y < __x); + } + friend bool operator>=(const PlanDescription& __x, const PlanDescription& __y) { + return !(__x < __y); + } +#endif + template > + FOLLY_ERASE ::apache::thrift::required_field_ref plan_node_descs_ref() const& { + return ::apache::thrift::required_field_ref{this->plan_node_descs}; + } + + template > + FOLLY_ERASE ::apache::thrift::required_field_ref plan_node_descs_ref() const&& { + return ::apache::thrift::required_field_ref{std::move(this->plan_node_descs)}; + } + + template > + FOLLY_ERASE ::apache::thrift::required_field_ref plan_node_descs_ref() & { + return ::apache::thrift::required_field_ref{this->plan_node_descs}; + } + + template > + FOLLY_ERASE ::apache::thrift::required_field_ref plan_node_descs_ref() && { + return ::apache::thrift::required_field_ref{std::move(this->plan_node_descs)}; + } + template > + FOLLY_ERASE ::apache::thrift::required_field_ref node_index_map_ref() const& { + return ::apache::thrift::required_field_ref{this->node_index_map}; + } + + template > + FOLLY_ERASE ::apache::thrift::required_field_ref node_index_map_ref() const&& { + return ::apache::thrift::required_field_ref{std::move(this->node_index_map)}; + } + + template > + FOLLY_ERASE ::apache::thrift::required_field_ref node_index_map_ref() & { + return ::apache::thrift::required_field_ref{this->node_index_map}; + } + + template > + FOLLY_ERASE ::apache::thrift::required_field_ref node_index_map_ref() && { + return ::apache::thrift::required_field_ref{std::move(this->node_index_map)}; + } + template + FOLLY_ERASE ::apache::thrift::required_field_ref format_ref() const& { + return ::apache::thrift::required_field_ref{this->format}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref format_ref() const&& { + return ::apache::thrift::required_field_ref{std::move(this->format)}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref format_ref() & { + return ::apache::thrift::required_field_ref{this->format}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref format_ref() && { + return ::apache::thrift::required_field_ref{std::move(this->format)}; + } + template + FOLLY_ERASE ::apache::thrift::required_field_ref optimize_time_in_us_ref() const& { + return ::apache::thrift::required_field_ref{this->optimize_time_in_us}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref optimize_time_in_us_ref() const&& { + return ::apache::thrift::required_field_ref{std::move(this->optimize_time_in_us)}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref optimize_time_in_us_ref() & { + return ::apache::thrift::required_field_ref{this->optimize_time_in_us}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref optimize_time_in_us_ref() && { + return ::apache::thrift::required_field_ref{std::move(this->optimize_time_in_us)}; + } + const ::std::vector& get_plan_node_descs() const&; + ::std::vector get_plan_node_descs() &&; + + template > + ::std::vector& set_plan_node_descs(T_PlanDescription_plan_node_descs_struct_setter&& plan_node_descs_) { + plan_node_descs = std::forward(plan_node_descs_); + return plan_node_descs; + } + const std::unordered_map& get_node_index_map() const&; + std::unordered_map get_node_index_map() &&; + + template > + std::unordered_map& set_node_index_map(T_PlanDescription_node_index_map_struct_setter&& node_index_map_) { + node_index_map = std::forward(node_index_map_); + return node_index_map; + } + + const ::std::string& get_format() const& { + return format; + } + + ::std::string get_format() && { + return std::move(format); + } + + template + ::std::string& set_format(T_PlanDescription_format_struct_setter&& format_) { + format = std::forward(format_); + return format; + } + + int32_t get_optimize_time_in_us() const { + return optimize_time_in_us; + } + + int32_t& set_optimize_time_in_us(int32_t optimize_time_in_us_) { + optimize_time_in_us = optimize_time_in_us_; + return optimize_time_in_us; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< PlanDescription >; + friend void swap(PlanDescription& a, PlanDescription& b); +}; + +template +uint32_t PlanDescription::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::graph::cpp2 +namespace nebula { namespace graph { namespace cpp2 { +class ExecutionResponse final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = ExecutionResponse; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + + ExecutionResponse(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + ExecutionResponse(apache::thrift::FragileConstructor, ::nebula::cpp2::ErrorCode error_code__arg, int32_t latency_in_us__arg, nebula::DataSet data__arg, ::std::string space_name__arg, ::std::string error_msg__arg, nebula::PlanDescription plan_desc__arg, ::std::string comment__arg); + + ExecutionResponse(ExecutionResponse&&) = default; + + ExecutionResponse(const ExecutionResponse&) = default; + + + ExecutionResponse& operator=(ExecutionResponse&&) = default; + + ExecutionResponse& operator=(const ExecutionResponse&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + + ~ExecutionResponse(); + + public: + ::nebula::cpp2::ErrorCode error_code; + public: + int32_t latency_in_us; + private: + nebula::DataSet data; + private: + ::std::string space_name; + private: + ::std::string error_msg; + private: + nebula::PlanDescription plan_desc; + private: + ::std::string comment; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool data; + bool space_name; + bool error_msg; + bool plan_desc; + bool comment; + } __isset = {}; + bool operator==(const ExecutionResponse& rhs) const; +#ifndef SWIG + friend bool operator!=(const ExecutionResponse& __x, const ExecutionResponse& __y) { + return !(__x == __y); + } +#endif + bool operator<(const ExecutionResponse& rhs) const; +#ifndef SWIG + friend bool operator>(const ExecutionResponse& __x, const ExecutionResponse& __y) { + return __y < __x; + } + friend bool operator<=(const ExecutionResponse& __x, const ExecutionResponse& __y) { + return !(__y < __x); + } + friend bool operator>=(const ExecutionResponse& __x, const ExecutionResponse& __y) { + return !(__x < __y); + } +#endif + template + FOLLY_ERASE ::apache::thrift::required_field_ref error_code_ref() const& { + return ::apache::thrift::required_field_ref{this->error_code}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref error_code_ref() const&& { + return ::apache::thrift::required_field_ref{std::move(this->error_code)}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref error_code_ref() & { + return ::apache::thrift::required_field_ref{this->error_code}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref error_code_ref() && { + return ::apache::thrift::required_field_ref{std::move(this->error_code)}; + } + template + FOLLY_ERASE ::apache::thrift::required_field_ref latency_in_us_ref() const& { + return ::apache::thrift::required_field_ref{this->latency_in_us}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref latency_in_us_ref() const&& { + return ::apache::thrift::required_field_ref{std::move(this->latency_in_us)}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref latency_in_us_ref() & { + return ::apache::thrift::required_field_ref{this->latency_in_us}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref latency_in_us_ref() && { + return ::apache::thrift::required_field_ref{std::move(this->latency_in_us)}; + } + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::optional_field_ref data_ref() const& { + return {this->data, __isset.data}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref data_ref() const&& { + return {std::move(this->data), __isset.data}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref data_ref() & { + return {this->data, __isset.data}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref data_ref() && { + return {std::move(this->data), __isset.data}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::optional_field_ref space_name_ref() const& { + return {this->space_name, __isset.space_name}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref space_name_ref() const&& { + return {std::move(this->space_name), __isset.space_name}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref space_name_ref() & { + return {this->space_name, __isset.space_name}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref space_name_ref() && { + return {std::move(this->space_name), __isset.space_name}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::optional_field_ref error_msg_ref() const& { + return {this->error_msg, __isset.error_msg}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref error_msg_ref() const&& { + return {std::move(this->error_msg), __isset.error_msg}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref error_msg_ref() & { + return {this->error_msg, __isset.error_msg}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref error_msg_ref() && { + return {std::move(this->error_msg), __isset.error_msg}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::optional_field_ref plan_desc_ref() const& { + return {this->plan_desc, __isset.plan_desc}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref plan_desc_ref() const&& { + return {std::move(this->plan_desc), __isset.plan_desc}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref plan_desc_ref() & { + return {this->plan_desc, __isset.plan_desc}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref plan_desc_ref() && { + return {std::move(this->plan_desc), __isset.plan_desc}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::optional_field_ref comment_ref() const& { + return {this->comment, __isset.comment}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref comment_ref() const&& { + return {std::move(this->comment), __isset.comment}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref comment_ref() & { + return {this->comment, __isset.comment}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref comment_ref() && { + return {std::move(this->comment), __isset.comment}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::ErrorCode get_error_code() const { + return error_code; + } + + ::nebula::cpp2::ErrorCode& set_error_code( ::nebula::cpp2::ErrorCode error_code_) { + error_code = error_code_; + return error_code; + } + + int32_t get_latency_in_us() const { + return latency_in_us; + } + + int32_t& set_latency_in_us(int32_t latency_in_us_) { + latency_in_us = latency_in_us_; + return latency_in_us; + } + const nebula::DataSet* get_data() const&; + nebula::DataSet* get_data() &; + nebula::DataSet* get_data() && = delete; + + template + nebula::DataSet& set_data(T_ExecutionResponse_data_struct_setter&& data_) { + data = std::forward(data_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.data = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return data; + } + + const ::std::string* get_space_name() const& { + return space_name_ref() ? std::addressof(space_name) : nullptr; + } + + ::std::string* get_space_name() & { + return space_name_ref() ? std::addressof(space_name) : nullptr; + } + ::std::string* get_space_name() && = delete; + + template + ::std::string& set_space_name(T_ExecutionResponse_space_name_struct_setter&& space_name_) { + space_name = std::forward(space_name_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.space_name = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return space_name; + } + + const ::std::string* get_error_msg() const& { + return error_msg_ref() ? std::addressof(error_msg) : nullptr; + } + + ::std::string* get_error_msg() & { + return error_msg_ref() ? std::addressof(error_msg) : nullptr; + } + ::std::string* get_error_msg() && = delete; + + template + ::std::string& set_error_msg(T_ExecutionResponse_error_msg_struct_setter&& error_msg_) { + error_msg = std::forward(error_msg_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.error_msg = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return error_msg; + } + const nebula::PlanDescription* get_plan_desc() const&; + nebula::PlanDescription* get_plan_desc() &; + nebula::PlanDescription* get_plan_desc() && = delete; + + template + nebula::PlanDescription& set_plan_desc(T_ExecutionResponse_plan_desc_struct_setter&& plan_desc_) { + plan_desc = std::forward(plan_desc_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.plan_desc = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return plan_desc; + } + + const ::std::string* get_comment() const& { + return comment_ref() ? std::addressof(comment) : nullptr; + } + + ::std::string* get_comment() & { + return comment_ref() ? std::addressof(comment) : nullptr; + } + ::std::string* get_comment() && = delete; + + template + ::std::string& set_comment(T_ExecutionResponse_comment_struct_setter&& comment_) { + comment = std::forward(comment_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.comment = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return comment; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< ExecutionResponse >; + friend void swap(ExecutionResponse& a, ExecutionResponse& b); +}; + +template +uint32_t ExecutionResponse::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::graph::cpp2 +namespace nebula { namespace graph { namespace cpp2 { +class AuthResponse final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = AuthResponse; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + + AuthResponse(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + AuthResponse(apache::thrift::FragileConstructor, ::nebula::cpp2::ErrorCode error_code__arg, ::std::string error_msg__arg, int64_t session_id__arg, int32_t time_zone_offset_seconds__arg, ::std::string time_zone_name__arg); + + AuthResponse(AuthResponse&&) = default; + + AuthResponse(const AuthResponse&) = default; + + + AuthResponse& operator=(AuthResponse&&) = default; + + AuthResponse& operator=(const AuthResponse&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + + ~AuthResponse(); + + public: + ::nebula::cpp2::ErrorCode error_code; + private: + ::std::string error_msg; + private: + int64_t session_id; + private: + int32_t time_zone_offset_seconds; + private: + ::std::string time_zone_name; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool error_msg; + bool session_id; + bool time_zone_offset_seconds; + bool time_zone_name; + } __isset = {}; + bool operator==(const AuthResponse& rhs) const; +#ifndef SWIG + friend bool operator!=(const AuthResponse& __x, const AuthResponse& __y) { + return !(__x == __y); + } +#endif + bool operator<(const AuthResponse& rhs) const; +#ifndef SWIG + friend bool operator>(const AuthResponse& __x, const AuthResponse& __y) { + return __y < __x; + } + friend bool operator<=(const AuthResponse& __x, const AuthResponse& __y) { + return !(__y < __x); + } + friend bool operator>=(const AuthResponse& __x, const AuthResponse& __y) { + return !(__x < __y); + } +#endif + template + FOLLY_ERASE ::apache::thrift::required_field_ref error_code_ref() const& { + return ::apache::thrift::required_field_ref{this->error_code}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref error_code_ref() const&& { + return ::apache::thrift::required_field_ref{std::move(this->error_code)}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref error_code_ref() & { + return ::apache::thrift::required_field_ref{this->error_code}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref error_code_ref() && { + return ::apache::thrift::required_field_ref{std::move(this->error_code)}; + } + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::optional_field_ref error_msg_ref() const& { + return {this->error_msg, __isset.error_msg}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref error_msg_ref() const&& { + return {std::move(this->error_msg), __isset.error_msg}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref error_msg_ref() & { + return {this->error_msg, __isset.error_msg}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref error_msg_ref() && { + return {std::move(this->error_msg), __isset.error_msg}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::optional_field_ref session_id_ref() const& { + return {this->session_id, __isset.session_id}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref session_id_ref() const&& { + return {std::move(this->session_id), __isset.session_id}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref session_id_ref() & { + return {this->session_id, __isset.session_id}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref session_id_ref() && { + return {std::move(this->session_id), __isset.session_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::optional_field_ref time_zone_offset_seconds_ref() const& { + return {this->time_zone_offset_seconds, __isset.time_zone_offset_seconds}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref time_zone_offset_seconds_ref() const&& { + return {std::move(this->time_zone_offset_seconds), __isset.time_zone_offset_seconds}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref time_zone_offset_seconds_ref() & { + return {this->time_zone_offset_seconds, __isset.time_zone_offset_seconds}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref time_zone_offset_seconds_ref() && { + return {std::move(this->time_zone_offset_seconds), __isset.time_zone_offset_seconds}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::optional_field_ref time_zone_name_ref() const& { + return {this->time_zone_name, __isset.time_zone_name}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref time_zone_name_ref() const&& { + return {std::move(this->time_zone_name), __isset.time_zone_name}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref time_zone_name_ref() & { + return {this->time_zone_name, __isset.time_zone_name}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref time_zone_name_ref() && { + return {std::move(this->time_zone_name), __isset.time_zone_name}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::ErrorCode get_error_code() const { + return error_code; + } + + ::nebula::cpp2::ErrorCode& set_error_code( ::nebula::cpp2::ErrorCode error_code_) { + error_code = error_code_; + return error_code; + } + + const ::std::string* get_error_msg() const& { + return error_msg_ref() ? std::addressof(error_msg) : nullptr; + } + + ::std::string* get_error_msg() & { + return error_msg_ref() ? std::addressof(error_msg) : nullptr; + } + ::std::string* get_error_msg() && = delete; + + template + ::std::string& set_error_msg(T_AuthResponse_error_msg_struct_setter&& error_msg_) { + error_msg = std::forward(error_msg_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.error_msg = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return error_msg; + } + + const int64_t* get_session_id() const& { + return session_id_ref() ? std::addressof(session_id) : nullptr; + } + + int64_t* get_session_id() & { + return session_id_ref() ? std::addressof(session_id) : nullptr; + } + int64_t* get_session_id() && = delete; + + int64_t& set_session_id(int64_t session_id_) { + session_id = session_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.session_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return session_id; + } + + const int32_t* get_time_zone_offset_seconds() const& { + return time_zone_offset_seconds_ref() ? std::addressof(time_zone_offset_seconds) : nullptr; + } + + int32_t* get_time_zone_offset_seconds() & { + return time_zone_offset_seconds_ref() ? std::addressof(time_zone_offset_seconds) : nullptr; + } + int32_t* get_time_zone_offset_seconds() && = delete; + + int32_t& set_time_zone_offset_seconds(int32_t time_zone_offset_seconds_) { + time_zone_offset_seconds = time_zone_offset_seconds_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.time_zone_offset_seconds = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return time_zone_offset_seconds; + } + + const ::std::string* get_time_zone_name() const& { + return time_zone_name_ref() ? std::addressof(time_zone_name) : nullptr; + } + + ::std::string* get_time_zone_name() & { + return time_zone_name_ref() ? std::addressof(time_zone_name) : nullptr; + } + ::std::string* get_time_zone_name() && = delete; + + template + ::std::string& set_time_zone_name(T_AuthResponse_time_zone_name_struct_setter&& time_zone_name_) { + time_zone_name = std::forward(time_zone_name_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.time_zone_name = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return time_zone_name; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< AuthResponse >; + friend void swap(AuthResponse& a, AuthResponse& b); +}; + +template +uint32_t AuthResponse::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::graph::cpp2 +namespace nebula { namespace graph { namespace cpp2 { +class VerifyClientVersionResp final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = VerifyClientVersionResp; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + VerifyClientVersionResp() : + error_code( ::nebula::cpp2::ErrorCode::SUCCEEDED) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + VerifyClientVersionResp(apache::thrift::FragileConstructor, ::nebula::cpp2::ErrorCode error_code__arg, ::std::string error_msg__arg); + + VerifyClientVersionResp(VerifyClientVersionResp&&) = default; + + VerifyClientVersionResp(const VerifyClientVersionResp&) = default; + + + VerifyClientVersionResp& operator=(VerifyClientVersionResp&&) = default; + + VerifyClientVersionResp& operator=(const VerifyClientVersionResp&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + public: + ::nebula::cpp2::ErrorCode error_code; + private: + ::std::string error_msg; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool error_msg; + } __isset = {}; + bool operator==(const VerifyClientVersionResp& rhs) const; +#ifndef SWIG + friend bool operator!=(const VerifyClientVersionResp& __x, const VerifyClientVersionResp& __y) { + return !(__x == __y); + } +#endif + bool operator<(const VerifyClientVersionResp& rhs) const; +#ifndef SWIG + friend bool operator>(const VerifyClientVersionResp& __x, const VerifyClientVersionResp& __y) { + return __y < __x; + } + friend bool operator<=(const VerifyClientVersionResp& __x, const VerifyClientVersionResp& __y) { + return !(__y < __x); + } + friend bool operator>=(const VerifyClientVersionResp& __x, const VerifyClientVersionResp& __y) { + return !(__x < __y); + } +#endif + template + FOLLY_ERASE ::apache::thrift::required_field_ref error_code_ref() const& { + return ::apache::thrift::required_field_ref{this->error_code}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref error_code_ref() const&& { + return ::apache::thrift::required_field_ref{std::move(this->error_code)}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref error_code_ref() & { + return ::apache::thrift::required_field_ref{this->error_code}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref error_code_ref() && { + return ::apache::thrift::required_field_ref{std::move(this->error_code)}; + } + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::optional_field_ref error_msg_ref() const& { + return {this->error_msg, __isset.error_msg}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref error_msg_ref() const&& { + return {std::move(this->error_msg), __isset.error_msg}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref error_msg_ref() & { + return {this->error_msg, __isset.error_msg}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref error_msg_ref() && { + return {std::move(this->error_msg), __isset.error_msg}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::ErrorCode get_error_code() const { + return error_code; + } + + ::nebula::cpp2::ErrorCode& set_error_code( ::nebula::cpp2::ErrorCode error_code_) { + error_code = error_code_; + return error_code; + } + + const ::std::string* get_error_msg() const& { + return error_msg_ref() ? std::addressof(error_msg) : nullptr; + } + + ::std::string* get_error_msg() & { + return error_msg_ref() ? std::addressof(error_msg) : nullptr; + } + ::std::string* get_error_msg() && = delete; + + template + ::std::string& set_error_msg(T_VerifyClientVersionResp_error_msg_struct_setter&& error_msg_) { + error_msg = std::forward(error_msg_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.error_msg = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return error_msg; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< VerifyClientVersionResp >; + friend void swap(VerifyClientVersionResp& a, VerifyClientVersionResp& b); +}; + +template +uint32_t VerifyClientVersionResp::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::graph::cpp2 +namespace nebula { namespace graph { namespace cpp2 { +class VerifyClientVersionReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = VerifyClientVersionReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + VerifyClientVersionReq() : + version(apache::thrift::StringTraits< std::string>::fromStringLiteral("2.6.0")) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + VerifyClientVersionReq(apache::thrift::FragileConstructor, ::std::string version__arg); + + VerifyClientVersionReq(VerifyClientVersionReq&&) = default; + + VerifyClientVersionReq(const VerifyClientVersionReq&) = default; + + + VerifyClientVersionReq& operator=(VerifyClientVersionReq&&) = default; + + VerifyClientVersionReq& operator=(const VerifyClientVersionReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + public: + ::std::string version; + + public: + bool operator==(const VerifyClientVersionReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const VerifyClientVersionReq& __x, const VerifyClientVersionReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const VerifyClientVersionReq& rhs) const; +#ifndef SWIG + friend bool operator>(const VerifyClientVersionReq& __x, const VerifyClientVersionReq& __y) { + return __y < __x; + } + friend bool operator<=(const VerifyClientVersionReq& __x, const VerifyClientVersionReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const VerifyClientVersionReq& __x, const VerifyClientVersionReq& __y) { + return !(__x < __y); + } +#endif + template + FOLLY_ERASE ::apache::thrift::required_field_ref version_ref() const& { + return ::apache::thrift::required_field_ref{this->version}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref version_ref() const&& { + return ::apache::thrift::required_field_ref{std::move(this->version)}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref version_ref() & { + return ::apache::thrift::required_field_ref{this->version}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref version_ref() && { + return ::apache::thrift::required_field_ref{std::move(this->version)}; + } + + const ::std::string& get_version() const& { + return version; + } + + ::std::string get_version() && { + return std::move(version); + } + + template + ::std::string& set_version(T_VerifyClientVersionReq_version_struct_setter&& version_) { + version = std::forward(version_); + return version; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< VerifyClientVersionReq >; + friend void swap(VerifyClientVersionReq& a, VerifyClientVersionReq& b); +}; + +template +uint32_t VerifyClientVersionReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::graph::cpp2 diff --git a/src/interface/gen-cpp2/graph_types.tcc b/src/interface/gen-cpp2/graph_types.tcc new file mode 100644 index 00000000..6a589140 --- /dev/null +++ b/src/interface/gen-cpp2/graph_types.tcc @@ -0,0 +1,1882 @@ +/** + * Autogenerated by Thrift for graph.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#pragma once + +#include "graph_types.h" + +#include + + +namespace apache { +namespace thrift { +namespace detail { + +template <> +struct TccStructTraits<::nebula::graph::cpp2::ProfilingStats> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::graph::cpp2::PlanNodeBranchInfo> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::graph::cpp2::Pair> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::graph::cpp2::PlanNodeDescription> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::graph::cpp2::PlanDescription> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::graph::cpp2::ExecutionResponse> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::graph::cpp2::AuthResponse> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::graph::cpp2::VerifyClientVersionResp> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::graph::cpp2::VerifyClientVersionReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace graph { namespace cpp2 { + +template +void ProfilingStats::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I64))) { + goto _loop; + } +_readField_rows: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::readWithContext(*iprot, this->rows, _readState); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_I64))) { + goto _loop; + } +_readField_exec_duration_in_us: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::readWithContext(*iprot, this->exec_duration_in_us, _readState); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_I64))) { + goto _loop; + } +_readField_total_duration_in_us: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::readWithContext(*iprot, this->total_duration_in_us, _readState); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 4, + apache::thrift::protocol::T_MAP))) { + goto _loop; + } +_readField_other_stats: + { + _readState.beforeSubobject(iprot); + this->other_stats = std::unordered_map<::std::string, ::std::string>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::binary, ::apache::thrift::type_class::binary>, std::unordered_map<::std::string, ::std::string>>::readWithContext(*iprot, this->other_stats, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.other_stats = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 4, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I64))) { + goto _readField_rows; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I64))) { + goto _readField_exec_duration_in_us; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I64))) { + goto _readField_total_duration_in_us; + } else { + goto _skip; + } + } + case 4: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_MAP))) { + goto _readField_other_stats; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t ProfilingStats::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ProfilingStats"); + xfer += prot_->serializedFieldSize("rows", apache::thrift::protocol::T_I64, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::serializedSize(*prot_, this->rows); + xfer += prot_->serializedFieldSize("exec_duration_in_us", apache::thrift::protocol::T_I64, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::serializedSize(*prot_, this->exec_duration_in_us); + xfer += prot_->serializedFieldSize("total_duration_in_us", apache::thrift::protocol::T_I64, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::serializedSize(*prot_, this->total_duration_in_us); + if (this->other_stats_ref().has_value()) { + xfer += prot_->serializedFieldSize("other_stats", apache::thrift::protocol::T_MAP, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::binary, ::apache::thrift::type_class::binary>, std::unordered_map<::std::string, ::std::string>>::serializedSize(*prot_, this->other_stats); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ProfilingStats::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ProfilingStats"); + xfer += prot_->serializedFieldSize("rows", apache::thrift::protocol::T_I64, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::serializedSize(*prot_, this->rows); + xfer += prot_->serializedFieldSize("exec_duration_in_us", apache::thrift::protocol::T_I64, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::serializedSize(*prot_, this->exec_duration_in_us); + xfer += prot_->serializedFieldSize("total_duration_in_us", apache::thrift::protocol::T_I64, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::serializedSize(*prot_, this->total_duration_in_us); + if (this->other_stats_ref().has_value()) { + xfer += prot_->serializedFieldSize("other_stats", apache::thrift::protocol::T_MAP, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::binary, ::apache::thrift::type_class::binary>, std::unordered_map<::std::string, ::std::string>>::serializedSize(*prot_, this->other_stats); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ProfilingStats::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("ProfilingStats"); + xfer += prot_->writeFieldBegin("rows", apache::thrift::protocol::T_I64, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::write(*prot_, this->rows); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("exec_duration_in_us", apache::thrift::protocol::T_I64, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::write(*prot_, this->exec_duration_in_us); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("total_duration_in_us", apache::thrift::protocol::T_I64, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::write(*prot_, this->total_duration_in_us); + xfer += prot_->writeFieldEnd(); + if (this->other_stats_ref().has_value()) { + xfer += prot_->writeFieldBegin("other_stats", apache::thrift::protocol::T_MAP, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::binary, ::apache::thrift::type_class::binary>, std::unordered_map<::std::string, ::std::string>>::write(*prot_, this->other_stats); + xfer += prot_->writeFieldEnd(); + } + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void ProfilingStats::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t ProfilingStats::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t ProfilingStats::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t ProfilingStats::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void ProfilingStats::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t ProfilingStats::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t ProfilingStats::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t ProfilingStats::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::graph::cpp2 +namespace nebula { namespace graph { namespace cpp2 { + +template +void PlanNodeBranchInfo::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_BOOL))) { + goto _loop; + } +_readField_is_do_branch: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::readWithContext(*iprot, this->is_do_branch, _readState); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_I64))) { + goto _loop; + } +_readField_condition_node_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::readWithContext(*iprot, this->condition_node_id, _readState); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_BOOL))) { + goto _readField_is_do_branch; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I64))) { + goto _readField_condition_node_id; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t PlanNodeBranchInfo::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("PlanNodeBranchInfo"); + xfer += prot_->serializedFieldSize("is_do_branch", apache::thrift::protocol::T_BOOL, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::serializedSize(*prot_, this->is_do_branch); + xfer += prot_->serializedFieldSize("condition_node_id", apache::thrift::protocol::T_I64, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::serializedSize(*prot_, this->condition_node_id); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t PlanNodeBranchInfo::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("PlanNodeBranchInfo"); + xfer += prot_->serializedFieldSize("is_do_branch", apache::thrift::protocol::T_BOOL, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::serializedSize(*prot_, this->is_do_branch); + xfer += prot_->serializedFieldSize("condition_node_id", apache::thrift::protocol::T_I64, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::serializedSize(*prot_, this->condition_node_id); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t PlanNodeBranchInfo::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("PlanNodeBranchInfo"); + xfer += prot_->writeFieldBegin("is_do_branch", apache::thrift::protocol::T_BOOL, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::write(*prot_, this->is_do_branch); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("condition_node_id", apache::thrift::protocol::T_I64, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::write(*prot_, this->condition_node_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void PlanNodeBranchInfo::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t PlanNodeBranchInfo::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t PlanNodeBranchInfo::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t PlanNodeBranchInfo::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void PlanNodeBranchInfo::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t PlanNodeBranchInfo::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t PlanNodeBranchInfo::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t PlanNodeBranchInfo::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::graph::cpp2 +namespace nebula { namespace graph { namespace cpp2 { + +template +void Pair::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_key: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->key, _readState); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_value: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->value, _readState); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_key; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_value; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t Pair::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("Pair"); + xfer += prot_->serializedFieldSize("key", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->key); + xfer += prot_->serializedFieldSize("value", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->value); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t Pair::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("Pair"); + xfer += prot_->serializedFieldSize("key", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->key); + xfer += prot_->serializedFieldSize("value", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->value); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t Pair::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("Pair"); + xfer += prot_->writeFieldBegin("key", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->key); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("value", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->value); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void Pair::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t Pair::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t Pair::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t Pair::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void Pair::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t Pair::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t Pair::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t Pair::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::graph::cpp2 +namespace nebula { namespace graph { namespace cpp2 { + +template +void PlanNodeDescription::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_name: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->name, _readState); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_I64))) { + goto _loop; + } +_readField_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::readWithContext(*iprot, this->id, _readState); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_output_var: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->output_var, _readState); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 4, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_description: + { + _readState.beforeSubobject(iprot); + this->description = ::std::vector(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector>::readWithContext(*iprot, this->description, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.description = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 4, + 5, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_profiles: + { + _readState.beforeSubobject(iprot); + this->profiles = ::std::vector(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector>::readWithContext(*iprot, this->profiles, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.profiles = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 5, + 6, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_branch_info: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::PlanNodeBranchInfo>::readWithContext(*iprot, this->branch_info, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.branch_info = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 6, + 7, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_dependencies: + { + _readState.beforeSubobject(iprot); + this->dependencies = ::std::vector(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::integral>, ::std::vector>::readWithContext(*iprot, this->dependencies, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.dependencies = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 7, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_name; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I64))) { + goto _readField_id; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_output_var; + } else { + goto _skip; + } + } + case 4: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_description; + } else { + goto _skip; + } + } + case 5: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_profiles; + } else { + goto _skip; + } + } + case 6: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_branch_info; + } else { + goto _skip; + } + } + case 7: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_dependencies; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t PlanNodeDescription::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("PlanNodeDescription"); + xfer += prot_->serializedFieldSize("name", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->name); + xfer += prot_->serializedFieldSize("id", apache::thrift::protocol::T_I64, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::serializedSize(*prot_, this->id); + xfer += prot_->serializedFieldSize("output_var", apache::thrift::protocol::T_STRING, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->output_var); + if (this->description_ref().has_value()) { + xfer += prot_->serializedFieldSize("description", apache::thrift::protocol::T_LIST, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector>::serializedSize(*prot_, this->description); + } + if (this->profiles_ref().has_value()) { + xfer += prot_->serializedFieldSize("profiles", apache::thrift::protocol::T_LIST, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector>::serializedSize(*prot_, this->profiles); + } + if (this->branch_info_ref().has_value()) { + xfer += prot_->serializedFieldSize("branch_info", apache::thrift::protocol::T_STRUCT, 6); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::PlanNodeBranchInfo>::serializedSize(*prot_, this->branch_info); + } + if (this->dependencies_ref().has_value()) { + xfer += prot_->serializedFieldSize("dependencies", apache::thrift::protocol::T_LIST, 7); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::integral>, ::std::vector>::serializedSize(*prot_, this->dependencies); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t PlanNodeDescription::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("PlanNodeDescription"); + xfer += prot_->serializedFieldSize("name", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->name); + xfer += prot_->serializedFieldSize("id", apache::thrift::protocol::T_I64, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::serializedSize(*prot_, this->id); + xfer += prot_->serializedFieldSize("output_var", apache::thrift::protocol::T_STRING, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->output_var); + if (this->description_ref().has_value()) { + xfer += prot_->serializedFieldSize("description", apache::thrift::protocol::T_LIST, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector>::serializedSize(*prot_, this->description); + } + if (this->profiles_ref().has_value()) { + xfer += prot_->serializedFieldSize("profiles", apache::thrift::protocol::T_LIST, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector>::serializedSize(*prot_, this->profiles); + } + if (this->branch_info_ref().has_value()) { + xfer += prot_->serializedFieldSize("branch_info", apache::thrift::protocol::T_STRUCT, 6); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::PlanNodeBranchInfo>::serializedSize(*prot_, this->branch_info); + } + if (this->dependencies_ref().has_value()) { + xfer += prot_->serializedFieldSize("dependencies", apache::thrift::protocol::T_LIST, 7); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::integral>, ::std::vector>::serializedSize(*prot_, this->dependencies); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t PlanNodeDescription::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("PlanNodeDescription"); + xfer += prot_->writeFieldBegin("name", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->name); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("id", apache::thrift::protocol::T_I64, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::write(*prot_, this->id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("output_var", apache::thrift::protocol::T_STRING, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->output_var); + xfer += prot_->writeFieldEnd(); + if (this->description_ref().has_value()) { + xfer += prot_->writeFieldBegin("description", apache::thrift::protocol::T_LIST, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector>::write(*prot_, this->description); + xfer += prot_->writeFieldEnd(); + } + if (this->profiles_ref().has_value()) { + xfer += prot_->writeFieldBegin("profiles", apache::thrift::protocol::T_LIST, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector>::write(*prot_, this->profiles); + xfer += prot_->writeFieldEnd(); + } + if (this->branch_info_ref().has_value()) { + xfer += prot_->writeFieldBegin("branch_info", apache::thrift::protocol::T_STRUCT, 6); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::PlanNodeBranchInfo>::write(*prot_, this->branch_info); + xfer += prot_->writeFieldEnd(); + } + if (this->dependencies_ref().has_value()) { + xfer += prot_->writeFieldBegin("dependencies", apache::thrift::protocol::T_LIST, 7); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::integral>, ::std::vector>::write(*prot_, this->dependencies); + xfer += prot_->writeFieldEnd(); + } + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void PlanNodeDescription::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t PlanNodeDescription::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t PlanNodeDescription::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t PlanNodeDescription::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void PlanNodeDescription::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t PlanNodeDescription::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t PlanNodeDescription::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t PlanNodeDescription::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::graph::cpp2 +namespace nebula { namespace graph { namespace cpp2 { + +template +void PlanDescription::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_plan_node_descs: + { + _readState.beforeSubobject(iprot); + this->plan_node_descs = ::std::vector(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector>::readWithContext(*iprot, this->plan_node_descs, _readState); + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_MAP))) { + goto _loop; + } +_readField_node_index_map: + { + _readState.beforeSubobject(iprot); + this->node_index_map = std::unordered_map(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::integral>, std::unordered_map>::readWithContext(*iprot, this->node_index_map, _readState); + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_format: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->format, _readState); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 4, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_optimize_time_in_us: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::readWithContext(*iprot, this->optimize_time_in_us, _readState); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 4, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_plan_node_descs; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_MAP))) { + goto _readField_node_index_map; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_format; + } else { + goto _skip; + } + } + case 4: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_optimize_time_in_us; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t PlanDescription::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("PlanDescription"); + xfer += prot_->serializedFieldSize("plan_node_descs", apache::thrift::protocol::T_LIST, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector>::serializedSize(*prot_, this->plan_node_descs); + xfer += prot_->serializedFieldSize("node_index_map", apache::thrift::protocol::T_MAP, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::integral>, std::unordered_map>::serializedSize(*prot_, this->node_index_map); + xfer += prot_->serializedFieldSize("format", apache::thrift::protocol::T_STRING, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->format); + xfer += prot_->serializedFieldSize("optimize_time_in_us", apache::thrift::protocol::T_I32, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::serializedSize(*prot_, this->optimize_time_in_us); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t PlanDescription::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("PlanDescription"); + xfer += prot_->serializedFieldSize("plan_node_descs", apache::thrift::protocol::T_LIST, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector>::serializedSize(*prot_, this->plan_node_descs); + xfer += prot_->serializedFieldSize("node_index_map", apache::thrift::protocol::T_MAP, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::integral>, std::unordered_map>::serializedSize(*prot_, this->node_index_map); + xfer += prot_->serializedFieldSize("format", apache::thrift::protocol::T_STRING, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->format); + xfer += prot_->serializedFieldSize("optimize_time_in_us", apache::thrift::protocol::T_I32, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::serializedSize(*prot_, this->optimize_time_in_us); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t PlanDescription::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("PlanDescription"); + xfer += prot_->writeFieldBegin("plan_node_descs", apache::thrift::protocol::T_LIST, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector>::write(*prot_, this->plan_node_descs); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("node_index_map", apache::thrift::protocol::T_MAP, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::integral>, std::unordered_map>::write(*prot_, this->node_index_map); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("format", apache::thrift::protocol::T_STRING, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->format); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("optimize_time_in_us", apache::thrift::protocol::T_I32, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::write(*prot_, this->optimize_time_in_us); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void PlanDescription::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t PlanDescription::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t PlanDescription::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t PlanDescription::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void PlanDescription::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t PlanDescription::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t PlanDescription::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t PlanDescription::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::graph::cpp2 +namespace nebula { namespace graph { namespace cpp2 { + +template +void ExecutionResponse::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_error_code: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::readWithContext(*iprot, this->error_code, _readState); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_latency_in_us: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::readWithContext(*iprot, this->latency_in_us, _readState); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_data: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::DataSet>::readWithContext(*iprot, this->data, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.data = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 4, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_space_name: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->space_name, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.space_name = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 4, + 5, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_error_msg: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->error_msg, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.error_msg = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 5, + 6, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_plan_desc: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::PlanDescription>::readWithContext(*iprot, this->plan_desc, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.plan_desc = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 6, + 7, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_comment: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->comment, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.comment = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 7, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_error_code; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_latency_in_us; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_data; + } else { + goto _skip; + } + } + case 4: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_space_name; + } else { + goto _skip; + } + } + case 5: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_error_msg; + } else { + goto _skip; + } + } + case 6: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_plan_desc; + } else { + goto _skip; + } + } + case 7: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_comment; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t ExecutionResponse::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ExecutionResponse"); + xfer += prot_->serializedFieldSize("error_code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::serializedSize(*prot_, this->error_code); + xfer += prot_->serializedFieldSize("latency_in_us", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::serializedSize(*prot_, this->latency_in_us); + if (this->data_ref().has_value()) { + xfer += prot_->serializedFieldSize("data", apache::thrift::protocol::T_STRUCT, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::DataSet>::serializedSize(*prot_, this->data); + } + if (this->space_name_ref().has_value()) { + xfer += prot_->serializedFieldSize("space_name", apache::thrift::protocol::T_STRING, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->space_name); + } + if (this->error_msg_ref().has_value()) { + xfer += prot_->serializedFieldSize("error_msg", apache::thrift::protocol::T_STRING, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->error_msg); + } + if (this->plan_desc_ref().has_value()) { + xfer += prot_->serializedFieldSize("plan_desc", apache::thrift::protocol::T_STRUCT, 6); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::PlanDescription>::serializedSize(*prot_, this->plan_desc); + } + if (this->comment_ref().has_value()) { + xfer += prot_->serializedFieldSize("comment", apache::thrift::protocol::T_STRING, 7); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->comment); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ExecutionResponse::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ExecutionResponse"); + xfer += prot_->serializedFieldSize("error_code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::serializedSize(*prot_, this->error_code); + xfer += prot_->serializedFieldSize("latency_in_us", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::serializedSize(*prot_, this->latency_in_us); + if (this->data_ref().has_value()) { + xfer += prot_->serializedFieldSize("data", apache::thrift::protocol::T_STRUCT, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::DataSet>::serializedSize(*prot_, this->data); + } + if (this->space_name_ref().has_value()) { + xfer += prot_->serializedFieldSize("space_name", apache::thrift::protocol::T_STRING, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->space_name); + } + if (this->error_msg_ref().has_value()) { + xfer += prot_->serializedFieldSize("error_msg", apache::thrift::protocol::T_STRING, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->error_msg); + } + if (this->plan_desc_ref().has_value()) { + xfer += prot_->serializedFieldSize("plan_desc", apache::thrift::protocol::T_STRUCT, 6); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::PlanDescription>::serializedSize(*prot_, this->plan_desc); + } + if (this->comment_ref().has_value()) { + xfer += prot_->serializedFieldSize("comment", apache::thrift::protocol::T_STRING, 7); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->comment); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ExecutionResponse::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("ExecutionResponse"); + xfer += prot_->writeFieldBegin("error_code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::write(*prot_, this->error_code); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("latency_in_us", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::write(*prot_, this->latency_in_us); + xfer += prot_->writeFieldEnd(); + if (this->data_ref().has_value()) { + xfer += prot_->writeFieldBegin("data", apache::thrift::protocol::T_STRUCT, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::DataSet>::write(*prot_, this->data); + xfer += prot_->writeFieldEnd(); + } + if (this->space_name_ref().has_value()) { + xfer += prot_->writeFieldBegin("space_name", apache::thrift::protocol::T_STRING, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->space_name); + xfer += prot_->writeFieldEnd(); + } + if (this->error_msg_ref().has_value()) { + xfer += prot_->writeFieldBegin("error_msg", apache::thrift::protocol::T_STRING, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->error_msg); + xfer += prot_->writeFieldEnd(); + } + if (this->plan_desc_ref().has_value()) { + xfer += prot_->writeFieldBegin("plan_desc", apache::thrift::protocol::T_STRUCT, 6); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::PlanDescription>::write(*prot_, this->plan_desc); + xfer += prot_->writeFieldEnd(); + } + if (this->comment_ref().has_value()) { + xfer += prot_->writeFieldBegin("comment", apache::thrift::protocol::T_STRING, 7); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->comment); + xfer += prot_->writeFieldEnd(); + } + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void ExecutionResponse::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t ExecutionResponse::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t ExecutionResponse::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t ExecutionResponse::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void ExecutionResponse::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t ExecutionResponse::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t ExecutionResponse::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t ExecutionResponse::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::graph::cpp2 +namespace nebula { namespace graph { namespace cpp2 { + +template +void AuthResponse::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_error_code: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::readWithContext(*iprot, this->error_code, _readState); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_error_msg: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->error_msg, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.error_msg = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_I64))) { + goto _loop; + } +_readField_session_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::readWithContext(*iprot, this->session_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.session_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 4, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_time_zone_offset_seconds: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::readWithContext(*iprot, this->time_zone_offset_seconds, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.time_zone_offset_seconds = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 4, + 5, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_time_zone_name: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->time_zone_name, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.time_zone_name = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 5, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_error_code; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_error_msg; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I64))) { + goto _readField_session_id; + } else { + goto _skip; + } + } + case 4: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_time_zone_offset_seconds; + } else { + goto _skip; + } + } + case 5: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_time_zone_name; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t AuthResponse::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("AuthResponse"); + xfer += prot_->serializedFieldSize("error_code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::serializedSize(*prot_, this->error_code); + if (this->error_msg_ref().has_value()) { + xfer += prot_->serializedFieldSize("error_msg", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->error_msg); + } + if (this->session_id_ref().has_value()) { + xfer += prot_->serializedFieldSize("session_id", apache::thrift::protocol::T_I64, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::serializedSize(*prot_, this->session_id); + } + if (this->time_zone_offset_seconds_ref().has_value()) { + xfer += prot_->serializedFieldSize("time_zone_offset_seconds", apache::thrift::protocol::T_I32, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::serializedSize(*prot_, this->time_zone_offset_seconds); + } + if (this->time_zone_name_ref().has_value()) { + xfer += prot_->serializedFieldSize("time_zone_name", apache::thrift::protocol::T_STRING, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->time_zone_name); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t AuthResponse::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("AuthResponse"); + xfer += prot_->serializedFieldSize("error_code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::serializedSize(*prot_, this->error_code); + if (this->error_msg_ref().has_value()) { + xfer += prot_->serializedFieldSize("error_msg", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->error_msg); + } + if (this->session_id_ref().has_value()) { + xfer += prot_->serializedFieldSize("session_id", apache::thrift::protocol::T_I64, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::serializedSize(*prot_, this->session_id); + } + if (this->time_zone_offset_seconds_ref().has_value()) { + xfer += prot_->serializedFieldSize("time_zone_offset_seconds", apache::thrift::protocol::T_I32, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::serializedSize(*prot_, this->time_zone_offset_seconds); + } + if (this->time_zone_name_ref().has_value()) { + xfer += prot_->serializedFieldSize("time_zone_name", apache::thrift::protocol::T_STRING, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->time_zone_name); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t AuthResponse::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("AuthResponse"); + xfer += prot_->writeFieldBegin("error_code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::write(*prot_, this->error_code); + xfer += prot_->writeFieldEnd(); + if (this->error_msg_ref().has_value()) { + xfer += prot_->writeFieldBegin("error_msg", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->error_msg); + xfer += prot_->writeFieldEnd(); + } + if (this->session_id_ref().has_value()) { + xfer += prot_->writeFieldBegin("session_id", apache::thrift::protocol::T_I64, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::write(*prot_, this->session_id); + xfer += prot_->writeFieldEnd(); + } + if (this->time_zone_offset_seconds_ref().has_value()) { + xfer += prot_->writeFieldBegin("time_zone_offset_seconds", apache::thrift::protocol::T_I32, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::write(*prot_, this->time_zone_offset_seconds); + xfer += prot_->writeFieldEnd(); + } + if (this->time_zone_name_ref().has_value()) { + xfer += prot_->writeFieldBegin("time_zone_name", apache::thrift::protocol::T_STRING, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->time_zone_name); + xfer += prot_->writeFieldEnd(); + } + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void AuthResponse::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t AuthResponse::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t AuthResponse::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t AuthResponse::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void AuthResponse::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t AuthResponse::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t AuthResponse::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t AuthResponse::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::graph::cpp2 +namespace nebula { namespace graph { namespace cpp2 { + +template +void VerifyClientVersionResp::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_error_code: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::readWithContext(*iprot, this->error_code, _readState); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_error_msg: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->error_msg, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.error_msg = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_error_code; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_error_msg; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t VerifyClientVersionResp::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("VerifyClientVersionResp"); + xfer += prot_->serializedFieldSize("error_code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::serializedSize(*prot_, this->error_code); + if (this->error_msg_ref().has_value()) { + xfer += prot_->serializedFieldSize("error_msg", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->error_msg); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t VerifyClientVersionResp::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("VerifyClientVersionResp"); + xfer += prot_->serializedFieldSize("error_code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::serializedSize(*prot_, this->error_code); + if (this->error_msg_ref().has_value()) { + xfer += prot_->serializedFieldSize("error_msg", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->error_msg); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t VerifyClientVersionResp::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("VerifyClientVersionResp"); + xfer += prot_->writeFieldBegin("error_code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::write(*prot_, this->error_code); + xfer += prot_->writeFieldEnd(); + if (this->error_msg_ref().has_value()) { + xfer += prot_->writeFieldBegin("error_msg", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->error_msg); + xfer += prot_->writeFieldEnd(); + } + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void VerifyClientVersionResp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t VerifyClientVersionResp::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t VerifyClientVersionResp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t VerifyClientVersionResp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void VerifyClientVersionResp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t VerifyClientVersionResp::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t VerifyClientVersionResp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t VerifyClientVersionResp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::graph::cpp2 +namespace nebula { namespace graph { namespace cpp2 { + +template +void VerifyClientVersionReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_version: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->version, _readState); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_version; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t VerifyClientVersionReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("VerifyClientVersionReq"); + xfer += prot_->serializedFieldSize("version", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->version); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t VerifyClientVersionReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("VerifyClientVersionReq"); + xfer += prot_->serializedFieldSize("version", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->version); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t VerifyClientVersionReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("VerifyClientVersionReq"); + xfer += prot_->writeFieldBegin("version", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->version); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void VerifyClientVersionReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t VerifyClientVersionReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t VerifyClientVersionReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t VerifyClientVersionReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void VerifyClientVersionReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t VerifyClientVersionReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t VerifyClientVersionReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t VerifyClientVersionReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::graph::cpp2 diff --git a/src/interface/gen-cpp2/graph_types_custom_protocol.h b/src/interface/gen-cpp2/graph_types_custom_protocol.h new file mode 100644 index 00000000..c86d9aa5 --- /dev/null +++ b/src/interface/gen-cpp2/graph_types_custom_protocol.h @@ -0,0 +1,19 @@ +/** + * Autogenerated by Thrift for graph.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#pragma once + + +/** + * This header file includes the tcc files of the corresponding header file + * and the header files of its dependent types. Include this header file + * only when you need to use custom protocols (e.g. DebugProtocol, + * VirtualProtocol) to read/write thrift structs. + */ + +#include "graph_types.tcc" + +#include "common_types_custom_protocol.h" diff --git a/src/interface/gen-cpp2/graph_visit_by_thrift_field_metadata.h b/src/interface/gen-cpp2/graph_visit_by_thrift_field_metadata.h new file mode 100644 index 00000000..8d6a235a --- /dev/null +++ b/src/interface/gen-cpp2/graph_visit_by_thrift_field_metadata.h @@ -0,0 +1,184 @@ +/** + * Autogenerated by Thrift for graph.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#pragma once + +#include +#include "graph_metadata.h" + +namespace apache { +namespace thrift { +namespace detail { + +template <> +struct VisitByThriftId<::nebula::graph::cpp2::ProfilingStats> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).rows_ref()); + case 2: + return f(1, static_cast(t).exec_duration_in_us_ref()); + case 3: + return f(2, static_cast(t).total_duration_in_us_ref()); + case 4: + return f(3, static_cast(t).other_stats_ref()); + default: + throwInvalidThriftId(id, "::nebula::graph::cpp2::ProfilingStats"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::graph::cpp2::PlanNodeBranchInfo> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).is_do_branch_ref()); + case 2: + return f(1, static_cast(t).condition_node_id_ref()); + default: + throwInvalidThriftId(id, "::nebula::graph::cpp2::PlanNodeBranchInfo"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::graph::cpp2::Pair> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).key_ref()); + case 2: + return f(1, static_cast(t).value_ref()); + default: + throwInvalidThriftId(id, "::nebula::graph::cpp2::Pair"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::graph::cpp2::PlanNodeDescription> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).name_ref()); + case 2: + return f(1, static_cast(t).id_ref()); + case 3: + return f(2, static_cast(t).output_var_ref()); + case 4: + return f(3, static_cast(t).description_ref()); + case 5: + return f(4, static_cast(t).profiles_ref()); + case 6: + return f(5, static_cast(t).branch_info_ref()); + case 7: + return f(6, static_cast(t).dependencies_ref()); + default: + throwInvalidThriftId(id, "::nebula::graph::cpp2::PlanNodeDescription"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::graph::cpp2::PlanDescription> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).plan_node_descs_ref()); + case 2: + return f(1, static_cast(t).node_index_map_ref()); + case 3: + return f(2, static_cast(t).format_ref()); + case 4: + return f(3, static_cast(t).optimize_time_in_us_ref()); + default: + throwInvalidThriftId(id, "::nebula::graph::cpp2::PlanDescription"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::graph::cpp2::ExecutionResponse> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).error_code_ref()); + case 2: + return f(1, static_cast(t).latency_in_us_ref()); + case 3: + return f(2, static_cast(t).data_ref()); + case 4: + return f(3, static_cast(t).space_name_ref()); + case 5: + return f(4, static_cast(t).error_msg_ref()); + case 6: + return f(5, static_cast(t).plan_desc_ref()); + case 7: + return f(6, static_cast(t).comment_ref()); + default: + throwInvalidThriftId(id, "::nebula::graph::cpp2::ExecutionResponse"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::graph::cpp2::AuthResponse> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).error_code_ref()); + case 2: + return f(1, static_cast(t).error_msg_ref()); + case 3: + return f(2, static_cast(t).session_id_ref()); + case 4: + return f(3, static_cast(t).time_zone_offset_seconds_ref()); + case 5: + return f(4, static_cast(t).time_zone_name_ref()); + default: + throwInvalidThriftId(id, "::nebula::graph::cpp2::AuthResponse"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::graph::cpp2::VerifyClientVersionResp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).error_code_ref()); + case 2: + return f(1, static_cast(t).error_msg_ref()); + default: + throwInvalidThriftId(id, "::nebula::graph::cpp2::VerifyClientVersionResp"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::graph::cpp2::VerifyClientVersionReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).version_ref()); + default: + throwInvalidThriftId(id, "::nebula::graph::cpp2::VerifyClientVersionReq"); + } + } +}; +} // namespace detail +} // namespace thrift +} // namespace apache diff --git a/src/interface/gen-cpp2/graph_visit_union.h b/src/interface/gen-cpp2/graph_visit_union.h new file mode 100644 index 00000000..7a8a9cfd --- /dev/null +++ b/src/interface/gen-cpp2/graph_visit_union.h @@ -0,0 +1,18 @@ +/** + * Autogenerated by Thrift for graph.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#pragma once + +#include "graph_metadata.h" +#include + +namespace apache { +namespace thrift { +namespace detail { + +} // namespace detail +} // namespace thrift +} // namespace apache diff --git a/src/interface/gen-cpp2/graph_visitation.h b/src/interface/gen-cpp2/graph_visitation.h new file mode 100644 index 00000000..91438bcc --- /dev/null +++ b/src/interface/gen-cpp2/graph_visitation.h @@ -0,0 +1,10 @@ +/** + * Autogenerated by Thrift for graph.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#pragma once +#include "common_visitation.h" +#include "graph_for_each_field.h" +#include "graph_visit_union.h" diff --git a/src/interface/gen-cpp2/meta_constants.cpp b/src/interface/gen-cpp2/meta_constants.cpp new file mode 100644 index 00000000..b2d84543 --- /dev/null +++ b/src/interface/gen-cpp2/meta_constants.cpp @@ -0,0 +1,6 @@ +/** + * Autogenerated by Thrift for meta.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ diff --git a/src/interface/gen-cpp2/meta_constants.h b/src/interface/gen-cpp2/meta_constants.h new file mode 100644 index 00000000..8518bbf8 --- /dev/null +++ b/src/interface/gen-cpp2/meta_constants.h @@ -0,0 +1,19 @@ +/** + * Autogenerated by Thrift for meta.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#pragma once + +#include + +#include "meta_types.h" + +namespace nebula { namespace meta { namespace cpp2 { + +struct meta_constants { + +}; + +}}} // nebula::meta::cpp2 diff --git a/src/interface/gen-cpp2/meta_data.cpp b/src/interface/gen-cpp2/meta_data.cpp new file mode 100644 index 00000000..753f60cb --- /dev/null +++ b/src/interface/gen-cpp2/meta_data.cpp @@ -0,0 +1,2782 @@ +/** + * Autogenerated by Thrift for meta.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ + +#include "meta_data.h" + +#include + +namespace apache { +namespace thrift { + +const std::array<::nebula::meta::cpp2::AlterSchemaOp, 4> TEnumDataStorage<::nebula::meta::cpp2::AlterSchemaOp>::values = {{ + type::ADD, + type::CHANGE, + type::DROP, + type::UNKNOWN, +}}; +const std::array TEnumDataStorage<::nebula::meta::cpp2::AlterSchemaOp>::names = {{ + "ADD", + "CHANGE", + "DROP", + "UNKNOWN", +}}; + +const std::array<::nebula::meta::cpp2::RoleType, 5> TEnumDataStorage<::nebula::meta::cpp2::RoleType>::values = {{ + type::GOD, + type::ADMIN, + type::DBA, + type::USER, + type::GUEST, +}}; +const std::array TEnumDataStorage<::nebula::meta::cpp2::RoleType>::names = {{ + "GOD", + "ADMIN", + "DBA", + "USER", + "GUEST", +}}; + +const std::array<::nebula::meta::cpp2::GeoShape, 4> TEnumDataStorage<::nebula::meta::cpp2::GeoShape>::values = {{ + type::ANY, + type::POINT, + type::LINESTRING, + type::POLYGON, +}}; +const std::array TEnumDataStorage<::nebula::meta::cpp2::GeoShape>::names = {{ + "ANY", + "POINT", + "LINESTRING", + "POLYGON", +}}; + +const std::array<::nebula::meta::cpp2::PropertyType, 16> TEnumDataStorage<::nebula::meta::cpp2::PropertyType>::values = {{ + type::UNKNOWN, + type::BOOL, + type::INT64, + type::VID, + type::FLOAT, + type::DOUBLE, + type::STRING, + type::FIXED_STRING, + type::INT8, + type::INT16, + type::INT32, + type::TIMESTAMP, + type::DATE, + type::DATETIME, + type::TIME, + type::GEOGRAPHY, +}}; +const std::array TEnumDataStorage<::nebula::meta::cpp2::PropertyType>::names = {{ + "UNKNOWN", + "BOOL", + "INT64", + "VID", + "FLOAT", + "DOUBLE", + "STRING", + "FIXED_STRING", + "INT8", + "INT16", + "INT32", + "TIMESTAMP", + "DATE", + "DATETIME", + "TIME", + "GEOGRAPHY", +}}; + +const std::array<::nebula::meta::cpp2::IsolationLevel, 2> TEnumDataStorage<::nebula::meta::cpp2::IsolationLevel>::values = {{ + type::DEFAULT, + type::TOSS, +}}; +const std::array TEnumDataStorage<::nebula::meta::cpp2::IsolationLevel>::names = {{ + "DEFAULT", + "TOSS", +}}; + +const std::array<::nebula::meta::cpp2::HostStatus, 3> TEnumDataStorage<::nebula::meta::cpp2::HostStatus>::values = {{ + type::ONLINE, + type::OFFLINE, + type::UNKNOWN, +}}; +const std::array TEnumDataStorage<::nebula::meta::cpp2::HostStatus>::names = {{ + "ONLINE", + "OFFLINE", + "UNKNOWN", +}}; + +const std::array<::nebula::meta::cpp2::SnapshotStatus, 2> TEnumDataStorage<::nebula::meta::cpp2::SnapshotStatus>::values = {{ + type::VALID, + type::INVALID, +}}; +const std::array TEnumDataStorage<::nebula::meta::cpp2::SnapshotStatus>::names = {{ + "VALID", + "INVALID", +}}; + +const std::array<::nebula::meta::cpp2::AdminJobOp, 5> TEnumDataStorage<::nebula::meta::cpp2::AdminJobOp>::values = {{ + type::ADD, + type::SHOW_All, + type::SHOW, + type::STOP, + type::RECOVER, +}}; +const std::array TEnumDataStorage<::nebula::meta::cpp2::AdminJobOp>::names = {{ + "ADD", + "SHOW_All", + "SHOW", + "STOP", + "RECOVER", +}}; + +const std::array<::nebula::meta::cpp2::AdminCmd, 10> TEnumDataStorage<::nebula::meta::cpp2::AdminCmd>::values = {{ + type::COMPACT, + type::FLUSH, + type::REBUILD_TAG_INDEX, + type::REBUILD_EDGE_INDEX, + type::REBUILD_FULLTEXT_INDEX, + type::STATS, + type::DATA_BALANCE, + type::DOWNLOAD, + type::INGEST, + type::UNKNOWN, +}}; +const std::array TEnumDataStorage<::nebula::meta::cpp2::AdminCmd>::names = {{ + "COMPACT", + "FLUSH", + "REBUILD_TAG_INDEX", + "REBUILD_EDGE_INDEX", + "REBUILD_FULLTEXT_INDEX", + "STATS", + "DATA_BALANCE", + "DOWNLOAD", + "INGEST", + "UNKNOWN", +}}; + +const std::array<::nebula::meta::cpp2::JobStatus, 6> TEnumDataStorage<::nebula::meta::cpp2::JobStatus>::values = {{ + type::QUEUE, + type::RUNNING, + type::FINISHED, + type::FAILED, + type::STOPPED, + type::INVALID, +}}; +const std::array TEnumDataStorage<::nebula::meta::cpp2::JobStatus>::names = {{ + "QUEUE", + "RUNNING", + "FINISHED", + "FAILED", + "STOPPED", + "INVALID", +}}; + +const std::array<::nebula::meta::cpp2::ListHostType, 4> TEnumDataStorage<::nebula::meta::cpp2::ListHostType>::values = {{ + type::ALLOC, + type::GRAPH, + type::META, + type::STORAGE, +}}; +const std::array TEnumDataStorage<::nebula::meta::cpp2::ListHostType>::names = {{ + "ALLOC", + "GRAPH", + "META", + "STORAGE", +}}; + +const std::array<::nebula::meta::cpp2::HostRole, 5> TEnumDataStorage<::nebula::meta::cpp2::HostRole>::values = {{ + type::GRAPH, + type::META, + type::STORAGE, + type::LISTENER, + type::UNKNOWN, +}}; +const std::array TEnumDataStorage<::nebula::meta::cpp2::HostRole>::names = {{ + "GRAPH", + "META", + "STORAGE", + "LISTENER", + "UNKNOWN", +}}; + +const std::array<::nebula::meta::cpp2::TaskResult, 4> TEnumDataStorage<::nebula::meta::cpp2::TaskResult>::values = {{ + type::SUCCEEDED, + type::FAILED, + type::IN_PROGRESS, + type::INVALID, +}}; +const std::array TEnumDataStorage<::nebula::meta::cpp2::TaskResult>::names = {{ + "SUCCEEDED", + "FAILED", + "IN_PROGRESS", + "INVALID", +}}; + +const std::array<::nebula::meta::cpp2::ConfigModule, 5> TEnumDataStorage<::nebula::meta::cpp2::ConfigModule>::values = {{ + type::UNKNOWN, + type::ALL, + type::GRAPH, + type::META, + type::STORAGE, +}}; +const std::array TEnumDataStorage<::nebula::meta::cpp2::ConfigModule>::names = {{ + "UNKNOWN", + "ALL", + "GRAPH", + "META", + "STORAGE", +}}; + +const std::array<::nebula::meta::cpp2::ConfigMode, 4> TEnumDataStorage<::nebula::meta::cpp2::ConfigMode>::values = {{ + type::IMMUTABLE, + type::REBOOT, + type::MUTABLE, + type::IGNORED, +}}; +const std::array TEnumDataStorage<::nebula::meta::cpp2::ConfigMode>::names = {{ + "IMMUTABLE", + "REBOOT", + "MUTABLE", + "IGNORED", +}}; + +const std::array<::nebula::meta::cpp2::ListenerType, 2> TEnumDataStorage<::nebula::meta::cpp2::ListenerType>::values = {{ + type::UNKNOWN, + type::ELASTICSEARCH, +}}; +const std::array TEnumDataStorage<::nebula::meta::cpp2::ListenerType>::names = {{ + "UNKNOWN", + "ELASTICSEARCH", +}}; + +const std::array<::nebula::meta::cpp2::FTServiceType, 1> TEnumDataStorage<::nebula::meta::cpp2::FTServiceType>::values = {{ + type::ELASTICSEARCH, +}}; +const std::array TEnumDataStorage<::nebula::meta::cpp2::FTServiceType>::names = {{ + "ELASTICSEARCH", +}}; + +const std::array<::nebula::meta::cpp2::QueryStatus, 2> TEnumDataStorage<::nebula::meta::cpp2::QueryStatus>::values = {{ + type::RUNNING, + type::KILLING, +}}; +const std::array TEnumDataStorage<::nebula::meta::cpp2::QueryStatus>::names = {{ + "RUNNING", + "KILLING", +}}; + +const std::array<::nebula::meta::cpp2::ID::Type, 5> TEnumDataStorage<::nebula::meta::cpp2::ID::Type>::values = {{ + type::space_id, + type::tag_id, + type::edge_type, + type::index_id, + type::cluster_id, +}}; +const std::array TEnumDataStorage<::nebula::meta::cpp2::ID::Type>::names = {{ + "space_id", + "tag_id", + "edge_type", + "index_id", + "cluster_id", +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::ID>::fields_names = {{ + "space_id", + "tag_id", + "edge_type", + "index_id", + "cluster_id", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::ID>::fields_ids = {{ + 1, + 2, + 3, + 4, + 5, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::ID>::fields_types = {{ + TType::T_I32, + TType::T_I32, + TType::T_I32, + TType::T_I32, + TType::T_I64, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::ColumnTypeDef>::fields_names = {{ + "type", + "type_length", + "geo_shape", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::ColumnTypeDef>::fields_ids = {{ + 1, + 2, + 3, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::ColumnTypeDef>::fields_types = {{ + TType::T_I32, + TType::T_I16, + TType::T_I32, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::ColumnDef>::fields_names = {{ + "name", + "type", + "default_value", + "nullable", + "comment", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::ColumnDef>::fields_ids = {{ + 1, + 2, + 3, + 4, + 5, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::ColumnDef>::fields_types = {{ + TType::T_STRING, + TType::T_STRUCT, + TType::T_STRING, + TType::T_BOOL, + TType::T_STRING, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::SchemaProp>::fields_names = {{ + "ttl_duration", + "ttl_col", + "comment", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::SchemaProp>::fields_ids = {{ + 1, + 2, + 3, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::SchemaProp>::fields_types = {{ + TType::T_I64, + TType::T_STRING, + TType::T_STRING, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::Schema>::fields_names = {{ + "columns", + "schema_prop", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::Schema>::fields_ids = {{ + 1, + 2, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::Schema>::fields_types = {{ + TType::T_LIST, + TType::T_STRUCT, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::IdName>::fields_names = {{ + "id", + "name", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::IdName>::fields_ids = {{ + 1, + 2, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::IdName>::fields_types = {{ + TType::T_STRUCT, + TType::T_STRING, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::SpaceDesc>::fields_names = {{ + "space_name", + "partition_num", + "replica_factor", + "charset_name", + "collate_name", + "vid_type", + "group_name", + "isolation_level", + "comment", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::SpaceDesc>::fields_ids = {{ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::SpaceDesc>::fields_types = {{ + TType::T_STRING, + TType::T_I32, + TType::T_I32, + TType::T_STRING, + TType::T_STRING, + TType::T_STRUCT, + TType::T_STRING, + TType::T_I32, + TType::T_STRING, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::SpaceItem>::fields_names = {{ + "space_id", + "properties", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::SpaceItem>::fields_ids = {{ + 1, + 2, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::SpaceItem>::fields_types = {{ + TType::T_I32, + TType::T_STRUCT, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::TagItem>::fields_names = {{ + "tag_id", + "tag_name", + "version", + "schema", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::TagItem>::fields_ids = {{ + 1, + 2, + 3, + 4, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::TagItem>::fields_types = {{ + TType::T_I32, + TType::T_STRING, + TType::T_I64, + TType::T_STRUCT, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::AlterSchemaItem>::fields_names = {{ + "op", + "schema", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::AlterSchemaItem>::fields_ids = {{ + 1, + 2, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::AlterSchemaItem>::fields_types = {{ + TType::T_I32, + TType::T_STRUCT, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::EdgeItem>::fields_names = {{ + "edge_type", + "edge_name", + "version", + "schema", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::EdgeItem>::fields_ids = {{ + 1, + 2, + 3, + 4, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::EdgeItem>::fields_types = {{ + TType::T_I32, + TType::T_STRING, + TType::T_I64, + TType::T_STRUCT, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::IndexItem>::fields_names = {{ + "index_id", + "index_name", + "schema_id", + "schema_name", + "fields", + "comment", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::IndexItem>::fields_ids = {{ + 1, + 2, + 3, + 4, + 5, + 6, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::IndexItem>::fields_types = {{ + TType::T_I32, + TType::T_STRING, + TType::T_STRUCT, + TType::T_STRING, + TType::T_LIST, + TType::T_STRING, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::HostItem>::fields_names = {{ + "hostAddr", + "status", + "leader_parts", + "all_parts", + "role", + "git_info_sha", + "zone_name", + "version", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::HostItem>::fields_ids = {{ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::HostItem>::fields_types = {{ + TType::T_STRUCT, + TType::T_I32, + TType::T_MAP, + TType::T_MAP, + TType::T_I32, + TType::T_STRING, + TType::T_STRING, + TType::T_STRING, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::UserItem>::fields_names = {{ + "account", + "is_lock", + "max_queries_per_hour", + "max_updates_per_hour", + "max_connections_per_hour", + "max_user_connections", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::UserItem>::fields_ids = {{ + 1, + 2, + 3, + 4, + 5, + 6, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::UserItem>::fields_types = {{ + TType::T_STRING, + TType::T_BOOL, + TType::T_I32, + TType::T_I32, + TType::T_I32, + TType::T_I32, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::RoleItem>::fields_names = {{ + "user_id", + "space_id", + "role_type", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::RoleItem>::fields_ids = {{ + 1, + 2, + 3, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::RoleItem>::fields_types = {{ + TType::T_STRING, + TType::T_I32, + TType::T_I32, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::ExecResp>::fields_names = {{ + "code", + "id", + "leader", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::ExecResp>::fields_ids = {{ + 1, + 2, + 3, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::ExecResp>::fields_types = {{ + TType::T_I32, + TType::T_STRUCT, + TType::T_STRUCT, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::AdminJobReq>::fields_names = {{ + "op", + "cmd", + "paras", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::AdminJobReq>::fields_ids = {{ + 1, + 2, + 3, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::AdminJobReq>::fields_types = {{ + TType::T_I32, + TType::T_I32, + TType::T_LIST, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::JobDesc>::fields_names = {{ + "id", + "cmd", + "paras", + "status", + "start_time", + "stop_time", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::JobDesc>::fields_ids = {{ + 1, + 2, + 3, + 4, + 5, + 6, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::JobDesc>::fields_types = {{ + TType::T_I32, + TType::T_I32, + TType::T_LIST, + TType::T_I32, + TType::T_I64, + TType::T_I64, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::TaskDesc>::fields_names = {{ + "task_id", + "host", + "status", + "start_time", + "stop_time", + "job_id", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::TaskDesc>::fields_ids = {{ + 1, + 2, + 3, + 4, + 5, + 6, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::TaskDesc>::fields_types = {{ + TType::T_I32, + TType::T_STRUCT, + TType::T_I32, + TType::T_I64, + TType::T_I64, + TType::T_I32, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::AdminJobResult>::fields_names = {{ + "job_id", + "job_desc", + "task_desc", + "recovered_job_num", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::AdminJobResult>::fields_ids = {{ + 1, + 2, + 3, + 4, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::AdminJobResult>::fields_types = {{ + TType::T_I32, + TType::T_LIST, + TType::T_LIST, + TType::T_I32, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::AdminJobResp>::fields_names = {{ + "code", + "leader", + "result", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::AdminJobResp>::fields_ids = {{ + 1, + 2, + 3, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::AdminJobResp>::fields_types = {{ + TType::T_I32, + TType::T_STRUCT, + TType::T_STRUCT, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::Correlativity>::fields_names = {{ + "part_id", + "proportion", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::Correlativity>::fields_ids = {{ + 1, + 2, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::Correlativity>::fields_types = {{ + TType::T_I32, + TType::T_DOUBLE, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::StatsItem>::fields_names = {{ + "tag_vertices", + "edges", + "space_vertices", + "space_edges", + "positive_part_correlativity", + "negative_part_correlativity", + "status", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::StatsItem>::fields_ids = {{ + 1, + 2, + 3, + 4, + 5, + 6, + 7, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::StatsItem>::fields_types = {{ + TType::T_MAP, + TType::T_MAP, + TType::T_I64, + TType::T_I64, + TType::T_MAP, + TType::T_MAP, + TType::T_I32, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::CreateSpaceReq>::fields_names = {{ + "properties", + "if_not_exists", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::CreateSpaceReq>::fields_ids = {{ + 1, + 2, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::CreateSpaceReq>::fields_types = {{ + TType::T_STRUCT, + TType::T_BOOL, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::CreateSpaceAsReq>::fields_names = {{ + "old_space_name", + "new_space_name", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::CreateSpaceAsReq>::fields_ids = {{ + 1, + 2, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::CreateSpaceAsReq>::fields_types = {{ + TType::T_STRING, + TType::T_STRING, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::DropSpaceReq>::fields_names = {{ + "space_name", + "if_exists", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::DropSpaceReq>::fields_ids = {{ + 1, + 2, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::DropSpaceReq>::fields_types = {{ + TType::T_STRING, + TType::T_BOOL, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::ListSpacesReq>::fields_names = {{ +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::ListSpacesReq>::fields_ids = {{ +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::ListSpacesReq>::fields_types = {{ +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::ListSpacesResp>::fields_names = {{ + "code", + "leader", + "spaces", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::ListSpacesResp>::fields_ids = {{ + 1, + 2, + 3, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::ListSpacesResp>::fields_types = {{ + TType::T_I32, + TType::T_STRUCT, + TType::T_LIST, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::GetSpaceReq>::fields_names = {{ + "space_name", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::GetSpaceReq>::fields_ids = {{ + 1, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::GetSpaceReq>::fields_types = {{ + TType::T_STRING, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::GetSpaceResp>::fields_names = {{ + "code", + "leader", + "item", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::GetSpaceResp>::fields_ids = {{ + 1, + 2, + 3, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::GetSpaceResp>::fields_types = {{ + TType::T_I32, + TType::T_STRUCT, + TType::T_STRUCT, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::CreateTagReq>::fields_names = {{ + "space_id", + "tag_name", + "schema", + "if_not_exists", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::CreateTagReq>::fields_ids = {{ + 1, + 2, + 3, + 4, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::CreateTagReq>::fields_types = {{ + TType::T_I32, + TType::T_STRING, + TType::T_STRUCT, + TType::T_BOOL, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::AlterTagReq>::fields_names = {{ + "space_id", + "tag_name", + "tag_items", + "schema_prop", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::AlterTagReq>::fields_ids = {{ + 1, + 2, + 3, + 4, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::AlterTagReq>::fields_types = {{ + TType::T_I32, + TType::T_STRING, + TType::T_LIST, + TType::T_STRUCT, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::DropTagReq>::fields_names = {{ + "space_id", + "tag_name", + "if_exists", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::DropTagReq>::fields_ids = {{ + 1, + 2, + 3, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::DropTagReq>::fields_types = {{ + TType::T_I32, + TType::T_STRING, + TType::T_BOOL, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::ListTagsReq>::fields_names = {{ + "space_id", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::ListTagsReq>::fields_ids = {{ + 1, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::ListTagsReq>::fields_types = {{ + TType::T_I32, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::ListTagsResp>::fields_names = {{ + "code", + "leader", + "tags", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::ListTagsResp>::fields_ids = {{ + 1, + 2, + 3, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::ListTagsResp>::fields_types = {{ + TType::T_I32, + TType::T_STRUCT, + TType::T_LIST, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::GetTagReq>::fields_names = {{ + "space_id", + "tag_name", + "version", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::GetTagReq>::fields_ids = {{ + 1, + 2, + 3, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::GetTagReq>::fields_types = {{ + TType::T_I32, + TType::T_STRING, + TType::T_I64, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::GetTagResp>::fields_names = {{ + "code", + "leader", + "schema", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::GetTagResp>::fields_ids = {{ + 1, + 2, + 3, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::GetTagResp>::fields_types = {{ + TType::T_I32, + TType::T_STRUCT, + TType::T_STRUCT, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::CreateEdgeReq>::fields_names = {{ + "space_id", + "edge_name", + "schema", + "if_not_exists", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::CreateEdgeReq>::fields_ids = {{ + 1, + 2, + 3, + 4, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::CreateEdgeReq>::fields_types = {{ + TType::T_I32, + TType::T_STRING, + TType::T_STRUCT, + TType::T_BOOL, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::AlterEdgeReq>::fields_names = {{ + "space_id", + "edge_name", + "edge_items", + "schema_prop", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::AlterEdgeReq>::fields_ids = {{ + 1, + 2, + 3, + 4, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::AlterEdgeReq>::fields_types = {{ + TType::T_I32, + TType::T_STRING, + TType::T_LIST, + TType::T_STRUCT, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::GetEdgeReq>::fields_names = {{ + "space_id", + "edge_name", + "version", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::GetEdgeReq>::fields_ids = {{ + 1, + 2, + 3, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::GetEdgeReq>::fields_types = {{ + TType::T_I32, + TType::T_STRING, + TType::T_I64, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::GetEdgeResp>::fields_names = {{ + "code", + "leader", + "schema", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::GetEdgeResp>::fields_ids = {{ + 1, + 2, + 3, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::GetEdgeResp>::fields_types = {{ + TType::T_I32, + TType::T_STRUCT, + TType::T_STRUCT, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::DropEdgeReq>::fields_names = {{ + "space_id", + "edge_name", + "if_exists", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::DropEdgeReq>::fields_ids = {{ + 1, + 2, + 3, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::DropEdgeReq>::fields_types = {{ + TType::T_I32, + TType::T_STRING, + TType::T_BOOL, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::ListEdgesReq>::fields_names = {{ + "space_id", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::ListEdgesReq>::fields_ids = {{ + 1, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::ListEdgesReq>::fields_types = {{ + TType::T_I32, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::ListEdgesResp>::fields_names = {{ + "code", + "leader", + "edges", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::ListEdgesResp>::fields_ids = {{ + 1, + 2, + 3, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::ListEdgesResp>::fields_types = {{ + TType::T_I32, + TType::T_STRUCT, + TType::T_LIST, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::ListHostsReq>::fields_names = {{ + "type", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::ListHostsReq>::fields_ids = {{ + 1, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::ListHostsReq>::fields_types = {{ + TType::T_I32, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::ListHostsResp>::fields_names = {{ + "code", + "leader", + "hosts", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::ListHostsResp>::fields_ids = {{ + 1, + 2, + 3, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::ListHostsResp>::fields_types = {{ + TType::T_I32, + TType::T_STRUCT, + TType::T_LIST, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::PartItem>::fields_names = {{ + "part_id", + "leader", + "peers", + "losts", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::PartItem>::fields_ids = {{ + 1, + 2, + 3, + 4, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::PartItem>::fields_types = {{ + TType::T_I32, + TType::T_STRUCT, + TType::T_LIST, + TType::T_LIST, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::ListPartsReq>::fields_names = {{ + "space_id", + "part_ids", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::ListPartsReq>::fields_ids = {{ + 1, + 2, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::ListPartsReq>::fields_types = {{ + TType::T_I32, + TType::T_LIST, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::ListPartsResp>::fields_names = {{ + "code", + "leader", + "parts", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::ListPartsResp>::fields_ids = {{ + 1, + 2, + 3, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::ListPartsResp>::fields_types = {{ + TType::T_I32, + TType::T_STRUCT, + TType::T_LIST, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::GetPartsAllocReq>::fields_names = {{ + "space_id", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::GetPartsAllocReq>::fields_ids = {{ + 1, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::GetPartsAllocReq>::fields_types = {{ + TType::T_I32, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::GetPartsAllocResp>::fields_names = {{ + "code", + "leader", + "parts", + "terms", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::GetPartsAllocResp>::fields_ids = {{ + 1, + 2, + 3, + 4, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::GetPartsAllocResp>::fields_types = {{ + TType::T_I32, + TType::T_STRUCT, + TType::T_MAP, + TType::T_MAP, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::MultiPutReq>::fields_names = {{ + "segment", + "pairs", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::MultiPutReq>::fields_ids = {{ + 1, + 2, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::MultiPutReq>::fields_types = {{ + TType::T_STRING, + TType::T_LIST, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::GetReq>::fields_names = {{ + "segment", + "key", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::GetReq>::fields_ids = {{ + 1, + 2, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::GetReq>::fields_types = {{ + TType::T_STRING, + TType::T_STRING, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::GetResp>::fields_names = {{ + "code", + "leader", + "value", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::GetResp>::fields_ids = {{ + 1, + 2, + 3, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::GetResp>::fields_types = {{ + TType::T_I32, + TType::T_STRUCT, + TType::T_STRING, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::MultiGetReq>::fields_names = {{ + "segment", + "keys", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::MultiGetReq>::fields_ids = {{ + 1, + 2, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::MultiGetReq>::fields_types = {{ + TType::T_STRING, + TType::T_LIST, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::MultiGetResp>::fields_names = {{ + "code", + "leader", + "values", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::MultiGetResp>::fields_ids = {{ + 1, + 2, + 3, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::MultiGetResp>::fields_types = {{ + TType::T_I32, + TType::T_STRUCT, + TType::T_LIST, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::RemoveReq>::fields_names = {{ + "segment", + "key", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::RemoveReq>::fields_ids = {{ + 1, + 2, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::RemoveReq>::fields_types = {{ + TType::T_STRING, + TType::T_STRING, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::RemoveRangeReq>::fields_names = {{ + "segment", + "start", + "end", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::RemoveRangeReq>::fields_ids = {{ + 1, + 2, + 3, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::RemoveRangeReq>::fields_types = {{ + TType::T_STRING, + TType::T_STRING, + TType::T_STRING, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::ScanReq>::fields_names = {{ + "segment", + "start", + "end", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::ScanReq>::fields_ids = {{ + 1, + 2, + 3, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::ScanReq>::fields_types = {{ + TType::T_STRING, + TType::T_STRING, + TType::T_STRING, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::ScanResp>::fields_names = {{ + "code", + "leader", + "values", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::ScanResp>::fields_ids = {{ + 1, + 2, + 3, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::ScanResp>::fields_types = {{ + TType::T_I32, + TType::T_STRUCT, + TType::T_LIST, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::HBResp>::fields_names = {{ + "code", + "leader", + "cluster_id", + "last_update_time_in_ms", + "meta_version", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::HBResp>::fields_ids = {{ + 1, + 2, + 3, + 4, + 5, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::HBResp>::fields_types = {{ + TType::T_I32, + TType::T_STRUCT, + TType::T_I64, + TType::T_I64, + TType::T_I32, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::LeaderInfo>::fields_names = {{ + "part_id", + "term", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::LeaderInfo>::fields_ids = {{ + 1, + 2, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::LeaderInfo>::fields_types = {{ + TType::T_I32, + TType::T_I64, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::HBReq>::fields_names = {{ + "role", + "host", + "cluster_id", + "leader_partIds", + "git_info_sha", + "version", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::HBReq>::fields_ids = {{ + 1, + 2, + 3, + 4, + 5, + 6, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::HBReq>::fields_types = {{ + TType::T_I32, + TType::T_STRUCT, + TType::T_I64, + TType::T_MAP, + TType::T_STRING, + TType::T_STRING, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::IndexFieldDef>::fields_names = {{ + "name", + "type_length", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::IndexFieldDef>::fields_ids = {{ + 1, + 2, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::IndexFieldDef>::fields_types = {{ + TType::T_STRING, + TType::T_I16, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::CreateTagIndexReq>::fields_names = {{ + "space_id", + "index_name", + "tag_name", + "fields", + "if_not_exists", + "comment", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::CreateTagIndexReq>::fields_ids = {{ + 1, + 2, + 3, + 4, + 5, + 6, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::CreateTagIndexReq>::fields_types = {{ + TType::T_I32, + TType::T_STRING, + TType::T_STRING, + TType::T_LIST, + TType::T_BOOL, + TType::T_STRING, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::DropTagIndexReq>::fields_names = {{ + "space_id", + "index_name", + "if_exists", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::DropTagIndexReq>::fields_ids = {{ + 1, + 2, + 3, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::DropTagIndexReq>::fields_types = {{ + TType::T_I32, + TType::T_STRING, + TType::T_BOOL, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::GetTagIndexReq>::fields_names = {{ + "space_id", + "index_name", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::GetTagIndexReq>::fields_ids = {{ + 1, + 2, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::GetTagIndexReq>::fields_types = {{ + TType::T_I32, + TType::T_STRING, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::GetTagIndexResp>::fields_names = {{ + "code", + "leader", + "item", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::GetTagIndexResp>::fields_ids = {{ + 1, + 2, + 3, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::GetTagIndexResp>::fields_types = {{ + TType::T_I32, + TType::T_STRUCT, + TType::T_STRUCT, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::ListTagIndexesReq>::fields_names = {{ + "space_id", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::ListTagIndexesReq>::fields_ids = {{ + 1, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::ListTagIndexesReq>::fields_types = {{ + TType::T_I32, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::ListTagIndexesResp>::fields_names = {{ + "code", + "leader", + "items", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::ListTagIndexesResp>::fields_ids = {{ + 1, + 2, + 3, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::ListTagIndexesResp>::fields_types = {{ + TType::T_I32, + TType::T_STRUCT, + TType::T_LIST, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::CreateEdgeIndexReq>::fields_names = {{ + "space_id", + "index_name", + "edge_name", + "fields", + "if_not_exists", + "comment", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::CreateEdgeIndexReq>::fields_ids = {{ + 1, + 2, + 3, + 4, + 5, + 6, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::CreateEdgeIndexReq>::fields_types = {{ + TType::T_I32, + TType::T_STRING, + TType::T_STRING, + TType::T_LIST, + TType::T_BOOL, + TType::T_STRING, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::DropEdgeIndexReq>::fields_names = {{ + "space_id", + "index_name", + "if_exists", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::DropEdgeIndexReq>::fields_ids = {{ + 1, + 2, + 3, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::DropEdgeIndexReq>::fields_types = {{ + TType::T_I32, + TType::T_STRING, + TType::T_BOOL, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::GetEdgeIndexReq>::fields_names = {{ + "space_id", + "index_name", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::GetEdgeIndexReq>::fields_ids = {{ + 1, + 2, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::GetEdgeIndexReq>::fields_types = {{ + TType::T_I32, + TType::T_STRING, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::GetEdgeIndexResp>::fields_names = {{ + "code", + "leader", + "item", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::GetEdgeIndexResp>::fields_ids = {{ + 1, + 2, + 3, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::GetEdgeIndexResp>::fields_types = {{ + TType::T_I32, + TType::T_STRUCT, + TType::T_STRUCT, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::ListEdgeIndexesReq>::fields_names = {{ + "space_id", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::ListEdgeIndexesReq>::fields_ids = {{ + 1, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::ListEdgeIndexesReq>::fields_types = {{ + TType::T_I32, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::ListEdgeIndexesResp>::fields_names = {{ + "code", + "leader", + "items", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::ListEdgeIndexesResp>::fields_ids = {{ + 1, + 2, + 3, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::ListEdgeIndexesResp>::fields_types = {{ + TType::T_I32, + TType::T_STRUCT, + TType::T_LIST, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::RebuildIndexReq>::fields_names = {{ + "space_id", + "index_name", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::RebuildIndexReq>::fields_ids = {{ + 1, + 2, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::RebuildIndexReq>::fields_types = {{ + TType::T_I32, + TType::T_STRING, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::CreateUserReq>::fields_names = {{ + "account", + "encoded_pwd", + "if_not_exists", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::CreateUserReq>::fields_ids = {{ + 1, + 2, + 3, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::CreateUserReq>::fields_types = {{ + TType::T_STRING, + TType::T_STRING, + TType::T_BOOL, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::DropUserReq>::fields_names = {{ + "account", + "if_exists", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::DropUserReq>::fields_ids = {{ + 1, + 2, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::DropUserReq>::fields_types = {{ + TType::T_STRING, + TType::T_BOOL, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::AlterUserReq>::fields_names = {{ + "account", + "encoded_pwd", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::AlterUserReq>::fields_ids = {{ + 1, + 2, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::AlterUserReq>::fields_types = {{ + TType::T_STRING, + TType::T_STRING, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::GrantRoleReq>::fields_names = {{ + "role_item", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::GrantRoleReq>::fields_ids = {{ + 1, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::GrantRoleReq>::fields_types = {{ + TType::T_STRUCT, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::RevokeRoleReq>::fields_names = {{ + "role_item", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::RevokeRoleReq>::fields_ids = {{ + 1, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::RevokeRoleReq>::fields_types = {{ + TType::T_STRUCT, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::ListUsersReq>::fields_names = {{ +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::ListUsersReq>::fields_ids = {{ +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::ListUsersReq>::fields_types = {{ +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::ListUsersResp>::fields_names = {{ + "code", + "leader", + "users", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::ListUsersResp>::fields_ids = {{ + 1, + 2, + 3, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::ListUsersResp>::fields_types = {{ + TType::T_I32, + TType::T_STRUCT, + TType::T_MAP, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::ListRolesReq>::fields_names = {{ + "space_id", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::ListRolesReq>::fields_ids = {{ + 1, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::ListRolesReq>::fields_types = {{ + TType::T_I32, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::ListRolesResp>::fields_names = {{ + "code", + "leader", + "roles", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::ListRolesResp>::fields_ids = {{ + 1, + 2, + 3, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::ListRolesResp>::fields_types = {{ + TType::T_I32, + TType::T_STRUCT, + TType::T_LIST, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::GetUserRolesReq>::fields_names = {{ + "account", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::GetUserRolesReq>::fields_ids = {{ + 1, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::GetUserRolesReq>::fields_types = {{ + TType::T_STRING, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::ChangePasswordReq>::fields_names = {{ + "account", + "new_encoded_pwd", + "old_encoded_pwd", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::ChangePasswordReq>::fields_ids = {{ + 1, + 2, + 3, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::ChangePasswordReq>::fields_types = {{ + TType::T_STRING, + TType::T_STRING, + TType::T_STRING, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::BalanceReq>::fields_names = {{ + "space_id", + "id", + "host_del", + "stop", + "reset", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::BalanceReq>::fields_ids = {{ + 1, + 2, + 3, + 4, + 5, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::BalanceReq>::fields_types = {{ + TType::T_I32, + TType::T_I64, + TType::T_LIST, + TType::T_BOOL, + TType::T_BOOL, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::BalanceTask>::fields_names = {{ + "id", + "result", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::BalanceTask>::fields_ids = {{ + 1, + 2, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::BalanceTask>::fields_types = {{ + TType::T_STRING, + TType::T_I32, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::BalanceResp>::fields_names = {{ + "code", + "id", + "leader", + "tasks", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::BalanceResp>::fields_ids = {{ + 1, + 2, + 3, + 4, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::BalanceResp>::fields_types = {{ + TType::T_I32, + TType::T_I64, + TType::T_STRUCT, + TType::T_LIST, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::LeaderBalanceReq>::fields_names = {{ +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::LeaderBalanceReq>::fields_ids = {{ +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::LeaderBalanceReq>::fields_types = {{ +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::ConfigItem>::fields_names = {{ + "module", + "name", + "mode", + "value", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::ConfigItem>::fields_ids = {{ + 1, + 2, + 3, + 4, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::ConfigItem>::fields_types = {{ + TType::T_I32, + TType::T_STRING, + TType::T_I32, + TType::T_STRUCT, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::RegConfigReq>::fields_names = {{ + "items", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::RegConfigReq>::fields_ids = {{ + 1, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::RegConfigReq>::fields_types = {{ + TType::T_LIST, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::GetConfigReq>::fields_names = {{ + "item", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::GetConfigReq>::fields_ids = {{ + 1, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::GetConfigReq>::fields_types = {{ + TType::T_STRUCT, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::GetConfigResp>::fields_names = {{ + "code", + "leader", + "items", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::GetConfigResp>::fields_ids = {{ + 1, + 2, + 3, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::GetConfigResp>::fields_types = {{ + TType::T_I32, + TType::T_STRUCT, + TType::T_LIST, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::SetConfigReq>::fields_names = {{ + "item", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::SetConfigReq>::fields_ids = {{ + 1, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::SetConfigReq>::fields_types = {{ + TType::T_STRUCT, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::ListConfigsReq>::fields_names = {{ + "space", + "module", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::ListConfigsReq>::fields_ids = {{ + 1, + 2, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::ListConfigsReq>::fields_types = {{ + TType::T_STRING, + TType::T_I32, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::ListConfigsResp>::fields_names = {{ + "code", + "leader", + "items", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::ListConfigsResp>::fields_ids = {{ + 1, + 2, + 3, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::ListConfigsResp>::fields_types = {{ + TType::T_I32, + TType::T_STRUCT, + TType::T_LIST, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::CreateSnapshotReq>::fields_names = {{ +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::CreateSnapshotReq>::fields_ids = {{ +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::CreateSnapshotReq>::fields_types = {{ +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::DropSnapshotReq>::fields_names = {{ + "name", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::DropSnapshotReq>::fields_ids = {{ + 1, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::DropSnapshotReq>::fields_types = {{ + TType::T_STRING, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::ListSnapshotsReq>::fields_names = {{ +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::ListSnapshotsReq>::fields_ids = {{ +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::ListSnapshotsReq>::fields_types = {{ +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::Snapshot>::fields_names = {{ + "name", + "status", + "hosts", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::Snapshot>::fields_ids = {{ + 1, + 2, + 3, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::Snapshot>::fields_types = {{ + TType::T_STRING, + TType::T_I32, + TType::T_STRING, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::ListSnapshotsResp>::fields_names = {{ + "code", + "leader", + "snapshots", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::ListSnapshotsResp>::fields_ids = {{ + 1, + 2, + 3, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::ListSnapshotsResp>::fields_types = {{ + TType::T_I32, + TType::T_STRUCT, + TType::T_LIST, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::ListIndexStatusReq>::fields_names = {{ + "space_id", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::ListIndexStatusReq>::fields_ids = {{ + 1, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::ListIndexStatusReq>::fields_types = {{ + TType::T_I32, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::IndexStatus>::fields_names = {{ + "name", + "status", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::IndexStatus>::fields_ids = {{ + 1, + 2, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::IndexStatus>::fields_types = {{ + TType::T_STRING, + TType::T_STRING, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::ListIndexStatusResp>::fields_names = {{ + "code", + "leader", + "statuses", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::ListIndexStatusResp>::fields_ids = {{ + 1, + 2, + 3, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::ListIndexStatusResp>::fields_types = {{ + TType::T_I32, + TType::T_STRUCT, + TType::T_LIST, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::AddZoneReq>::fields_names = {{ + "zone_name", + "nodes", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::AddZoneReq>::fields_ids = {{ + 1, + 2, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::AddZoneReq>::fields_types = {{ + TType::T_STRING, + TType::T_LIST, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::DropZoneReq>::fields_names = {{ + "zone_name", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::DropZoneReq>::fields_ids = {{ + 1, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::DropZoneReq>::fields_types = {{ + TType::T_STRING, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::AddHostIntoZoneReq>::fields_names = {{ + "node", + "zone_name", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::AddHostIntoZoneReq>::fields_ids = {{ + 1, + 2, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::AddHostIntoZoneReq>::fields_types = {{ + TType::T_STRUCT, + TType::T_STRING, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::DropHostFromZoneReq>::fields_names = {{ + "node", + "zone_name", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::DropHostFromZoneReq>::fields_ids = {{ + 1, + 2, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::DropHostFromZoneReq>::fields_types = {{ + TType::T_STRUCT, + TType::T_STRING, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::GetZoneReq>::fields_names = {{ + "zone_name", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::GetZoneReq>::fields_ids = {{ + 1, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::GetZoneReq>::fields_types = {{ + TType::T_STRING, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::GetZoneResp>::fields_names = {{ + "code", + "leader", + "hosts", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::GetZoneResp>::fields_ids = {{ + 1, + 2, + 3, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::GetZoneResp>::fields_types = {{ + TType::T_I32, + TType::T_STRUCT, + TType::T_LIST, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::ListZonesReq>::fields_names = {{ +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::ListZonesReq>::fields_ids = {{ +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::ListZonesReq>::fields_types = {{ +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::Zone>::fields_names = {{ + "zone_name", + "nodes", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::Zone>::fields_ids = {{ + 1, + 2, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::Zone>::fields_types = {{ + TType::T_STRING, + TType::T_LIST, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::ListZonesResp>::fields_names = {{ + "code", + "leader", + "zones", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::ListZonesResp>::fields_ids = {{ + 1, + 2, + 3, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::ListZonesResp>::fields_types = {{ + TType::T_I32, + TType::T_STRUCT, + TType::T_LIST, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::AddGroupReq>::fields_names = {{ + "group_name", + "zone_names", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::AddGroupReq>::fields_ids = {{ + 1, + 2, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::AddGroupReq>::fields_types = {{ + TType::T_STRING, + TType::T_LIST, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::DropGroupReq>::fields_names = {{ + "group_name", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::DropGroupReq>::fields_ids = {{ + 1, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::DropGroupReq>::fields_types = {{ + TType::T_STRING, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::AddZoneIntoGroupReq>::fields_names = {{ + "zone_name", + "group_name", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::AddZoneIntoGroupReq>::fields_ids = {{ + 1, + 2, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::AddZoneIntoGroupReq>::fields_types = {{ + TType::T_STRING, + TType::T_STRING, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::DropZoneFromGroupReq>::fields_names = {{ + "zone_name", + "group_name", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::DropZoneFromGroupReq>::fields_ids = {{ + 1, + 2, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::DropZoneFromGroupReq>::fields_types = {{ + TType::T_STRING, + TType::T_STRING, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::GetGroupReq>::fields_names = {{ + "group_name", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::GetGroupReq>::fields_ids = {{ + 1, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::GetGroupReq>::fields_types = {{ + TType::T_STRING, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::GetGroupResp>::fields_names = {{ + "code", + "leader", + "zone_names", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::GetGroupResp>::fields_ids = {{ + 1, + 2, + 3, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::GetGroupResp>::fields_types = {{ + TType::T_I32, + TType::T_STRUCT, + TType::T_LIST, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::ListGroupsReq>::fields_names = {{ +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::ListGroupsReq>::fields_ids = {{ +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::ListGroupsReq>::fields_types = {{ +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::Group>::fields_names = {{ + "group_name", + "zone_names", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::Group>::fields_ids = {{ + 1, + 2, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::Group>::fields_types = {{ + TType::T_STRING, + TType::T_LIST, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::ListGroupsResp>::fields_names = {{ + "code", + "leader", + "groups", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::ListGroupsResp>::fields_ids = {{ + 1, + 2, + 3, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::ListGroupsResp>::fields_types = {{ + TType::T_I32, + TType::T_STRUCT, + TType::T_LIST, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::AddListenerReq>::fields_names = {{ + "space_id", + "type", + "hosts", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::AddListenerReq>::fields_ids = {{ + 1, + 2, + 3, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::AddListenerReq>::fields_types = {{ + TType::T_I32, + TType::T_I32, + TType::T_LIST, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::RemoveListenerReq>::fields_names = {{ + "space_id", + "type", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::RemoveListenerReq>::fields_ids = {{ + 1, + 2, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::RemoveListenerReq>::fields_types = {{ + TType::T_I32, + TType::T_I32, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::ListListenerReq>::fields_names = {{ + "space_id", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::ListListenerReq>::fields_ids = {{ + 1, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::ListListenerReq>::fields_types = {{ + TType::T_I32, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::ListenerInfo>::fields_names = {{ + "type", + "host", + "part_id", + "status", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::ListenerInfo>::fields_ids = {{ + 1, + 2, + 3, + 4, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::ListenerInfo>::fields_types = {{ + TType::T_I32, + TType::T_STRUCT, + TType::T_I32, + TType::T_I32, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::ListListenerResp>::fields_names = {{ + "code", + "leader", + "listeners", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::ListListenerResp>::fields_ids = {{ + 1, + 2, + 3, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::ListListenerResp>::fields_types = {{ + TType::T_I32, + TType::T_STRUCT, + TType::T_LIST, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::GetStatsReq>::fields_names = {{ + "space_id", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::GetStatsReq>::fields_ids = {{ + 1, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::GetStatsReq>::fields_types = {{ + TType::T_I32, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::GetStatsResp>::fields_names = {{ + "code", + "leader", + "stats", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::GetStatsResp>::fields_ids = {{ + 1, + 2, + 3, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::GetStatsResp>::fields_types = {{ + TType::T_I32, + TType::T_STRUCT, + TType::T_STRUCT, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::BackupInfo>::fields_names = {{ + "host", + "info", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::BackupInfo>::fields_ids = {{ + 1, + 2, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::BackupInfo>::fields_types = {{ + TType::T_STRUCT, + TType::T_LIST, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::SpaceBackupInfo>::fields_names = {{ + "space", + "info", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::SpaceBackupInfo>::fields_ids = {{ + 1, + 2, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::SpaceBackupInfo>::fields_types = {{ + TType::T_STRUCT, + TType::T_LIST, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::BackupMeta>::fields_names = {{ + "backup_info", + "meta_files", + "backup_name", + "full", + "include_system_space", + "create_time", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::BackupMeta>::fields_ids = {{ + 1, + 2, + 3, + 4, + 5, + 6, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::BackupMeta>::fields_types = {{ + TType::T_MAP, + TType::T_LIST, + TType::T_STRING, + TType::T_BOOL, + TType::T_BOOL, + TType::T_I64, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::CreateBackupReq>::fields_names = {{ + "spaces", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::CreateBackupReq>::fields_ids = {{ + 1, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::CreateBackupReq>::fields_types = {{ + TType::T_LIST, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::CreateBackupResp>::fields_names = {{ + "code", + "leader", + "meta", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::CreateBackupResp>::fields_ids = {{ + 1, + 2, + 3, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::CreateBackupResp>::fields_types = {{ + TType::T_I32, + TType::T_STRUCT, + TType::T_STRUCT, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::HostPair>::fields_names = {{ + "from_host", + "to_host", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::HostPair>::fields_ids = {{ + 1, + 2, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::HostPair>::fields_types = {{ + TType::T_STRUCT, + TType::T_STRUCT, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::RestoreMetaReq>::fields_names = {{ + "files", + "hosts", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::RestoreMetaReq>::fields_ids = {{ + 1, + 2, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::RestoreMetaReq>::fields_types = {{ + TType::T_LIST, + TType::T_LIST, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::FTClient>::fields_names = {{ + "host", + "user", + "pwd", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::FTClient>::fields_ids = {{ + 1, + 2, + 3, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::FTClient>::fields_types = {{ + TType::T_STRUCT, + TType::T_STRING, + TType::T_STRING, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::SignInFTServiceReq>::fields_names = {{ + "type", + "clients", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::SignInFTServiceReq>::fields_ids = {{ + 1, + 2, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::SignInFTServiceReq>::fields_types = {{ + TType::T_I32, + TType::T_LIST, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::SignOutFTServiceReq>::fields_names = {{ +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::SignOutFTServiceReq>::fields_ids = {{ +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::SignOutFTServiceReq>::fields_types = {{ +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::ListFTClientsReq>::fields_names = {{ +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::ListFTClientsReq>::fields_ids = {{ +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::ListFTClientsReq>::fields_types = {{ +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::ListFTClientsResp>::fields_names = {{ + "code", + "leader", + "clients", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::ListFTClientsResp>::fields_ids = {{ + 1, + 2, + 3, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::ListFTClientsResp>::fields_types = {{ + TType::T_I32, + TType::T_STRUCT, + TType::T_LIST, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::FTIndex>::fields_names = {{ + "space_id", + "depend_schema", + "fields", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::FTIndex>::fields_ids = {{ + 1, + 2, + 3, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::FTIndex>::fields_types = {{ + TType::T_I32, + TType::T_STRUCT, + TType::T_LIST, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::CreateFTIndexReq>::fields_names = {{ + "fulltext_index_name", + "index", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::CreateFTIndexReq>::fields_ids = {{ + 1, + 2, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::CreateFTIndexReq>::fields_types = {{ + TType::T_STRING, + TType::T_STRUCT, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::DropFTIndexReq>::fields_names = {{ + "space_id", + "fulltext_index_name", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::DropFTIndexReq>::fields_ids = {{ + 1, + 2, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::DropFTIndexReq>::fields_types = {{ + TType::T_I32, + TType::T_STRING, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::ListFTIndexesReq>::fields_names = {{ +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::ListFTIndexesReq>::fields_ids = {{ +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::ListFTIndexesReq>::fields_types = {{ +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::ListFTIndexesResp>::fields_names = {{ + "code", + "leader", + "indexes", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::ListFTIndexesResp>::fields_ids = {{ + 1, + 2, + 3, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::ListFTIndexesResp>::fields_types = {{ + TType::T_I32, + TType::T_STRUCT, + TType::T_MAP, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::QueryDesc>::fields_names = {{ + "start_time", + "status", + "duration", + "query", + "graph_addr", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::QueryDesc>::fields_ids = {{ + 1, + 2, + 3, + 4, + 5, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::QueryDesc>::fields_types = {{ + TType::T_I64, + TType::T_I32, + TType::T_I64, + TType::T_STRING, + TType::T_STRUCT, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::Session>::fields_names = {{ + "session_id", + "create_time", + "update_time", + "user_name", + "space_name", + "graph_addr", + "timezone", + "client_ip", + "configs", + "queries", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::Session>::fields_ids = {{ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::Session>::fields_types = {{ + TType::T_I64, + TType::T_I64, + TType::T_I64, + TType::T_STRING, + TType::T_STRING, + TType::T_STRUCT, + TType::T_I32, + TType::T_STRING, + TType::T_MAP, + TType::T_MAP, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::CreateSessionReq>::fields_names = {{ + "user", + "graph_addr", + "client_ip", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::CreateSessionReq>::fields_ids = {{ + 1, + 2, + 3, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::CreateSessionReq>::fields_types = {{ + TType::T_STRING, + TType::T_STRUCT, + TType::T_STRING, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::CreateSessionResp>::fields_names = {{ + "code", + "leader", + "session", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::CreateSessionResp>::fields_ids = {{ + 1, + 2, + 3, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::CreateSessionResp>::fields_types = {{ + TType::T_I32, + TType::T_STRUCT, + TType::T_STRUCT, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::UpdateSessionsReq>::fields_names = {{ + "sessions", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::UpdateSessionsReq>::fields_ids = {{ + 1, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::UpdateSessionsReq>::fields_types = {{ + TType::T_LIST, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::UpdateSessionsResp>::fields_names = {{ + "code", + "leader", + "killed_queries", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::UpdateSessionsResp>::fields_ids = {{ + 1, + 2, + 3, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::UpdateSessionsResp>::fields_types = {{ + TType::T_I32, + TType::T_STRUCT, + TType::T_MAP, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::ListSessionsReq>::fields_names = {{ +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::ListSessionsReq>::fields_ids = {{ +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::ListSessionsReq>::fields_types = {{ +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::ListSessionsResp>::fields_names = {{ + "code", + "leader", + "sessions", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::ListSessionsResp>::fields_ids = {{ + 1, + 2, + 3, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::ListSessionsResp>::fields_types = {{ + TType::T_I32, + TType::T_STRUCT, + TType::T_LIST, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::GetSessionReq>::fields_names = {{ + "session_id", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::GetSessionReq>::fields_ids = {{ + 1, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::GetSessionReq>::fields_types = {{ + TType::T_I64, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::GetSessionResp>::fields_names = {{ + "code", + "leader", + "session", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::GetSessionResp>::fields_ids = {{ + 1, + 2, + 3, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::GetSessionResp>::fields_types = {{ + TType::T_I32, + TType::T_STRUCT, + TType::T_STRUCT, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::RemoveSessionReq>::fields_names = {{ + "session_id", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::RemoveSessionReq>::fields_ids = {{ + 1, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::RemoveSessionReq>::fields_types = {{ + TType::T_I64, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::KillQueryReq>::fields_names = {{ + "kill_queries", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::KillQueryReq>::fields_ids = {{ + 1, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::KillQueryReq>::fields_types = {{ + TType::T_MAP, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::ReportTaskReq>::fields_names = {{ + "code", + "job_id", + "task_id", + "stats", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::ReportTaskReq>::fields_ids = {{ + 1, + 2, + 3, + 4, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::ReportTaskReq>::fields_types = {{ + TType::T_I32, + TType::T_I32, + TType::T_I32, + TType::T_STRUCT, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::ListClusterInfoResp>::fields_names = {{ + "code", + "leader", + "meta_servers", + "storage_servers", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::ListClusterInfoResp>::fields_ids = {{ + 1, + 2, + 3, + 4, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::ListClusterInfoResp>::fields_types = {{ + TType::T_I32, + TType::T_STRUCT, + TType::T_LIST, + TType::T_LIST, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::ListClusterInfoReq>::fields_names = {{ +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::ListClusterInfoReq>::fields_ids = {{ +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::ListClusterInfoReq>::fields_types = {{ +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::GetMetaDirInfoResp>::fields_names = {{ + "code", + "dir", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::GetMetaDirInfoResp>::fields_ids = {{ + 1, + 2, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::GetMetaDirInfoResp>::fields_types = {{ + TType::T_I32, + TType::T_STRUCT, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::GetMetaDirInfoReq>::fields_names = {{ +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::GetMetaDirInfoReq>::fields_ids = {{ +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::GetMetaDirInfoReq>::fields_types = {{ +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::VerifyClientVersionResp>::fields_names = {{ + "code", + "leader", + "error_msg", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::VerifyClientVersionResp>::fields_ids = {{ + 1, + 2, + 3, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::VerifyClientVersionResp>::fields_types = {{ + TType::T_I32, + TType::T_STRUCT, + TType::T_STRING, +}}; + +const std::array TStructDataStorage<::nebula::meta::cpp2::VerifyClientVersionReq>::fields_names = {{ + "version", +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::VerifyClientVersionReq>::fields_ids = {{ + 1, +}}; +const std::array TStructDataStorage<::nebula::meta::cpp2::VerifyClientVersionReq>::fields_types = {{ + TType::T_STRING, +}}; + +} // namespace thrift +} // namespace apache diff --git a/src/interface/gen-cpp2/meta_data.h b/src/interface/gen-cpp2/meta_data.h new file mode 100644 index 00000000..6170285b --- /dev/null +++ b/src/interface/gen-cpp2/meta_data.h @@ -0,0 +1,1324 @@ +/** + * Autogenerated by Thrift for meta.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#pragma once + +#include + +#include "meta_types.h" + +namespace apache { namespace thrift { + +template <> struct TEnumDataStorage<::nebula::meta::cpp2::AlterSchemaOp> { + using type = ::nebula::meta::cpp2::AlterSchemaOp; + static constexpr const std::size_t size = 4; + static const std::array values; + static const std::array names; +}; + +template <> struct TEnumDataStorage<::nebula::meta::cpp2::RoleType> { + using type = ::nebula::meta::cpp2::RoleType; + static constexpr const std::size_t size = 5; + static const std::array values; + static const std::array names; +}; + +template <> struct TEnumDataStorage<::nebula::meta::cpp2::GeoShape> { + using type = ::nebula::meta::cpp2::GeoShape; + static constexpr const std::size_t size = 4; + static const std::array values; + static const std::array names; +}; + +template <> struct TEnumDataStorage<::nebula::meta::cpp2::PropertyType> { + using type = ::nebula::meta::cpp2::PropertyType; + static constexpr const std::size_t size = 16; + static const std::array values; + static const std::array names; +}; + +template <> struct TEnumDataStorage<::nebula::meta::cpp2::IsolationLevel> { + using type = ::nebula::meta::cpp2::IsolationLevel; + static constexpr const std::size_t size = 2; + static const std::array values; + static const std::array names; +}; + +template <> struct TEnumDataStorage<::nebula::meta::cpp2::HostStatus> { + using type = ::nebula::meta::cpp2::HostStatus; + static constexpr const std::size_t size = 3; + static const std::array values; + static const std::array names; +}; + +template <> struct TEnumDataStorage<::nebula::meta::cpp2::SnapshotStatus> { + using type = ::nebula::meta::cpp2::SnapshotStatus; + static constexpr const std::size_t size = 2; + static const std::array values; + static const std::array names; +}; + +template <> struct TEnumDataStorage<::nebula::meta::cpp2::AdminJobOp> { + using type = ::nebula::meta::cpp2::AdminJobOp; + static constexpr const std::size_t size = 5; + static const std::array values; + static const std::array names; +}; + +template <> struct TEnumDataStorage<::nebula::meta::cpp2::AdminCmd> { + using type = ::nebula::meta::cpp2::AdminCmd; + static constexpr const std::size_t size = 10; + static const std::array values; + static const std::array names; +}; + +template <> struct TEnumDataStorage<::nebula::meta::cpp2::JobStatus> { + using type = ::nebula::meta::cpp2::JobStatus; + static constexpr const std::size_t size = 6; + static const std::array values; + static const std::array names; +}; + +template <> struct TEnumDataStorage<::nebula::meta::cpp2::ListHostType> { + using type = ::nebula::meta::cpp2::ListHostType; + static constexpr const std::size_t size = 4; + static const std::array values; + static const std::array names; +}; + +template <> struct TEnumDataStorage<::nebula::meta::cpp2::HostRole> { + using type = ::nebula::meta::cpp2::HostRole; + static constexpr const std::size_t size = 5; + static const std::array values; + static const std::array names; +}; + +template <> struct TEnumDataStorage<::nebula::meta::cpp2::TaskResult> { + using type = ::nebula::meta::cpp2::TaskResult; + static constexpr const std::size_t size = 4; + static const std::array values; + static const std::array names; +}; + +template <> struct TEnumDataStorage<::nebula::meta::cpp2::ConfigModule> { + using type = ::nebula::meta::cpp2::ConfigModule; + static constexpr const std::size_t size = 5; + static const std::array values; + static const std::array names; +}; + +template <> struct TEnumDataStorage<::nebula::meta::cpp2::ConfigMode> { + using type = ::nebula::meta::cpp2::ConfigMode; + static constexpr const std::size_t size = 4; + static const std::array values; + static const std::array names; +}; + +template <> struct TEnumDataStorage<::nebula::meta::cpp2::ListenerType> { + using type = ::nebula::meta::cpp2::ListenerType; + static constexpr const std::size_t size = 2; + static const std::array values; + static const std::array names; +}; + +template <> struct TEnumDataStorage<::nebula::meta::cpp2::FTServiceType> { + using type = ::nebula::meta::cpp2::FTServiceType; + static constexpr const std::size_t size = 1; + static const std::array values; + static const std::array names; +}; + +template <> struct TEnumDataStorage<::nebula::meta::cpp2::QueryStatus> { + using type = ::nebula::meta::cpp2::QueryStatus; + static constexpr const std::size_t size = 2; + static const std::array values; + static const std::array names; +}; + +template <> struct TEnumDataStorage<::nebula::meta::cpp2::ID::Type> { + using type = ::nebula::meta::cpp2::ID::Type; + static constexpr const std::size_t size = 5; + static const std::array values; + static const std::array names; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::ID> { + static constexpr const std::size_t fields_size = 5; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::ColumnTypeDef> { + static constexpr const std::size_t fields_size = 3; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::ColumnDef> { + static constexpr const std::size_t fields_size = 5; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::SchemaProp> { + static constexpr const std::size_t fields_size = 3; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::Schema> { + static constexpr const std::size_t fields_size = 2; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::IdName> { + static constexpr const std::size_t fields_size = 2; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::SpaceDesc> { + static constexpr const std::size_t fields_size = 9; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::SpaceItem> { + static constexpr const std::size_t fields_size = 2; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::TagItem> { + static constexpr const std::size_t fields_size = 4; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::AlterSchemaItem> { + static constexpr const std::size_t fields_size = 2; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::EdgeItem> { + static constexpr const std::size_t fields_size = 4; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::IndexItem> { + static constexpr const std::size_t fields_size = 6; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::HostItem> { + static constexpr const std::size_t fields_size = 8; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::UserItem> { + static constexpr const std::size_t fields_size = 6; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::RoleItem> { + static constexpr const std::size_t fields_size = 3; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::ExecResp> { + static constexpr const std::size_t fields_size = 3; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::AdminJobReq> { + static constexpr const std::size_t fields_size = 3; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::JobDesc> { + static constexpr const std::size_t fields_size = 6; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::TaskDesc> { + static constexpr const std::size_t fields_size = 6; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::AdminJobResult> { + static constexpr const std::size_t fields_size = 4; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::AdminJobResp> { + static constexpr const std::size_t fields_size = 3; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::Correlativity> { + static constexpr const std::size_t fields_size = 2; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::StatsItem> { + static constexpr const std::size_t fields_size = 7; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::CreateSpaceReq> { + static constexpr const std::size_t fields_size = 2; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::CreateSpaceAsReq> { + static constexpr const std::size_t fields_size = 2; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::DropSpaceReq> { + static constexpr const std::size_t fields_size = 2; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::ListSpacesReq> { + static constexpr const std::size_t fields_size = 0; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::ListSpacesResp> { + static constexpr const std::size_t fields_size = 3; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::GetSpaceReq> { + static constexpr const std::size_t fields_size = 1; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::GetSpaceResp> { + static constexpr const std::size_t fields_size = 3; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::CreateTagReq> { + static constexpr const std::size_t fields_size = 4; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::AlterTagReq> { + static constexpr const std::size_t fields_size = 4; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::DropTagReq> { + static constexpr const std::size_t fields_size = 3; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::ListTagsReq> { + static constexpr const std::size_t fields_size = 1; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::ListTagsResp> { + static constexpr const std::size_t fields_size = 3; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::GetTagReq> { + static constexpr const std::size_t fields_size = 3; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::GetTagResp> { + static constexpr const std::size_t fields_size = 3; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::CreateEdgeReq> { + static constexpr const std::size_t fields_size = 4; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::AlterEdgeReq> { + static constexpr const std::size_t fields_size = 4; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::GetEdgeReq> { + static constexpr const std::size_t fields_size = 3; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::GetEdgeResp> { + static constexpr const std::size_t fields_size = 3; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::DropEdgeReq> { + static constexpr const std::size_t fields_size = 3; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::ListEdgesReq> { + static constexpr const std::size_t fields_size = 1; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::ListEdgesResp> { + static constexpr const std::size_t fields_size = 3; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::ListHostsReq> { + static constexpr const std::size_t fields_size = 1; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::ListHostsResp> { + static constexpr const std::size_t fields_size = 3; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::PartItem> { + static constexpr const std::size_t fields_size = 4; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::ListPartsReq> { + static constexpr const std::size_t fields_size = 2; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::ListPartsResp> { + static constexpr const std::size_t fields_size = 3; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::GetPartsAllocReq> { + static constexpr const std::size_t fields_size = 1; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::GetPartsAllocResp> { + static constexpr const std::size_t fields_size = 4; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::MultiPutReq> { + static constexpr const std::size_t fields_size = 2; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::GetReq> { + static constexpr const std::size_t fields_size = 2; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::GetResp> { + static constexpr const std::size_t fields_size = 3; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::MultiGetReq> { + static constexpr const std::size_t fields_size = 2; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::MultiGetResp> { + static constexpr const std::size_t fields_size = 3; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::RemoveReq> { + static constexpr const std::size_t fields_size = 2; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::RemoveRangeReq> { + static constexpr const std::size_t fields_size = 3; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::ScanReq> { + static constexpr const std::size_t fields_size = 3; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::ScanResp> { + static constexpr const std::size_t fields_size = 3; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::HBResp> { + static constexpr const std::size_t fields_size = 5; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::LeaderInfo> { + static constexpr const std::size_t fields_size = 2; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::HBReq> { + static constexpr const std::size_t fields_size = 6; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::IndexFieldDef> { + static constexpr const std::size_t fields_size = 2; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::CreateTagIndexReq> { + static constexpr const std::size_t fields_size = 6; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::DropTagIndexReq> { + static constexpr const std::size_t fields_size = 3; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::GetTagIndexReq> { + static constexpr const std::size_t fields_size = 2; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::GetTagIndexResp> { + static constexpr const std::size_t fields_size = 3; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::ListTagIndexesReq> { + static constexpr const std::size_t fields_size = 1; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::ListTagIndexesResp> { + static constexpr const std::size_t fields_size = 3; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::CreateEdgeIndexReq> { + static constexpr const std::size_t fields_size = 6; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::DropEdgeIndexReq> { + static constexpr const std::size_t fields_size = 3; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::GetEdgeIndexReq> { + static constexpr const std::size_t fields_size = 2; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::GetEdgeIndexResp> { + static constexpr const std::size_t fields_size = 3; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::ListEdgeIndexesReq> { + static constexpr const std::size_t fields_size = 1; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::ListEdgeIndexesResp> { + static constexpr const std::size_t fields_size = 3; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::RebuildIndexReq> { + static constexpr const std::size_t fields_size = 2; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::CreateUserReq> { + static constexpr const std::size_t fields_size = 3; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::DropUserReq> { + static constexpr const std::size_t fields_size = 2; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::AlterUserReq> { + static constexpr const std::size_t fields_size = 2; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::GrantRoleReq> { + static constexpr const std::size_t fields_size = 1; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::RevokeRoleReq> { + static constexpr const std::size_t fields_size = 1; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::ListUsersReq> { + static constexpr const std::size_t fields_size = 0; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::ListUsersResp> { + static constexpr const std::size_t fields_size = 3; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::ListRolesReq> { + static constexpr const std::size_t fields_size = 1; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::ListRolesResp> { + static constexpr const std::size_t fields_size = 3; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::GetUserRolesReq> { + static constexpr const std::size_t fields_size = 1; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::ChangePasswordReq> { + static constexpr const std::size_t fields_size = 3; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::BalanceReq> { + static constexpr const std::size_t fields_size = 5; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::BalanceTask> { + static constexpr const std::size_t fields_size = 2; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::BalanceResp> { + static constexpr const std::size_t fields_size = 4; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::LeaderBalanceReq> { + static constexpr const std::size_t fields_size = 0; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::ConfigItem> { + static constexpr const std::size_t fields_size = 4; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::RegConfigReq> { + static constexpr const std::size_t fields_size = 1; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::GetConfigReq> { + static constexpr const std::size_t fields_size = 1; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::GetConfigResp> { + static constexpr const std::size_t fields_size = 3; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::SetConfigReq> { + static constexpr const std::size_t fields_size = 1; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::ListConfigsReq> { + static constexpr const std::size_t fields_size = 2; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::ListConfigsResp> { + static constexpr const std::size_t fields_size = 3; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::CreateSnapshotReq> { + static constexpr const std::size_t fields_size = 0; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::DropSnapshotReq> { + static constexpr const std::size_t fields_size = 1; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::ListSnapshotsReq> { + static constexpr const std::size_t fields_size = 0; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::Snapshot> { + static constexpr const std::size_t fields_size = 3; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::ListSnapshotsResp> { + static constexpr const std::size_t fields_size = 3; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::ListIndexStatusReq> { + static constexpr const std::size_t fields_size = 1; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::IndexStatus> { + static constexpr const std::size_t fields_size = 2; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::ListIndexStatusResp> { + static constexpr const std::size_t fields_size = 3; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::AddZoneReq> { + static constexpr const std::size_t fields_size = 2; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::DropZoneReq> { + static constexpr const std::size_t fields_size = 1; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::AddHostIntoZoneReq> { + static constexpr const std::size_t fields_size = 2; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::DropHostFromZoneReq> { + static constexpr const std::size_t fields_size = 2; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::GetZoneReq> { + static constexpr const std::size_t fields_size = 1; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::GetZoneResp> { + static constexpr const std::size_t fields_size = 3; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::ListZonesReq> { + static constexpr const std::size_t fields_size = 0; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::Zone> { + static constexpr const std::size_t fields_size = 2; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::ListZonesResp> { + static constexpr const std::size_t fields_size = 3; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::AddGroupReq> { + static constexpr const std::size_t fields_size = 2; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::DropGroupReq> { + static constexpr const std::size_t fields_size = 1; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::AddZoneIntoGroupReq> { + static constexpr const std::size_t fields_size = 2; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::DropZoneFromGroupReq> { + static constexpr const std::size_t fields_size = 2; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::GetGroupReq> { + static constexpr const std::size_t fields_size = 1; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::GetGroupResp> { + static constexpr const std::size_t fields_size = 3; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::ListGroupsReq> { + static constexpr const std::size_t fields_size = 0; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::Group> { + static constexpr const std::size_t fields_size = 2; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::ListGroupsResp> { + static constexpr const std::size_t fields_size = 3; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::AddListenerReq> { + static constexpr const std::size_t fields_size = 3; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::RemoveListenerReq> { + static constexpr const std::size_t fields_size = 2; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::ListListenerReq> { + static constexpr const std::size_t fields_size = 1; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::ListenerInfo> { + static constexpr const std::size_t fields_size = 4; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::ListListenerResp> { + static constexpr const std::size_t fields_size = 3; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::GetStatsReq> { + static constexpr const std::size_t fields_size = 1; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::GetStatsResp> { + static constexpr const std::size_t fields_size = 3; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::BackupInfo> { + static constexpr const std::size_t fields_size = 2; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::SpaceBackupInfo> { + static constexpr const std::size_t fields_size = 2; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::BackupMeta> { + static constexpr const std::size_t fields_size = 6; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::CreateBackupReq> { + static constexpr const std::size_t fields_size = 1; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::CreateBackupResp> { + static constexpr const std::size_t fields_size = 3; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::HostPair> { + static constexpr const std::size_t fields_size = 2; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::RestoreMetaReq> { + static constexpr const std::size_t fields_size = 2; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::FTClient> { + static constexpr const std::size_t fields_size = 3; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::SignInFTServiceReq> { + static constexpr const std::size_t fields_size = 2; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::SignOutFTServiceReq> { + static constexpr const std::size_t fields_size = 0; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::ListFTClientsReq> { + static constexpr const std::size_t fields_size = 0; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::ListFTClientsResp> { + static constexpr const std::size_t fields_size = 3; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::FTIndex> { + static constexpr const std::size_t fields_size = 3; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::CreateFTIndexReq> { + static constexpr const std::size_t fields_size = 2; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::DropFTIndexReq> { + static constexpr const std::size_t fields_size = 2; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::ListFTIndexesReq> { + static constexpr const std::size_t fields_size = 0; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::ListFTIndexesResp> { + static constexpr const std::size_t fields_size = 3; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::QueryDesc> { + static constexpr const std::size_t fields_size = 5; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::Session> { + static constexpr const std::size_t fields_size = 10; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::CreateSessionReq> { + static constexpr const std::size_t fields_size = 3; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::CreateSessionResp> { + static constexpr const std::size_t fields_size = 3; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::UpdateSessionsReq> { + static constexpr const std::size_t fields_size = 1; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::UpdateSessionsResp> { + static constexpr const std::size_t fields_size = 3; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::ListSessionsReq> { + static constexpr const std::size_t fields_size = 0; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::ListSessionsResp> { + static constexpr const std::size_t fields_size = 3; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::GetSessionReq> { + static constexpr const std::size_t fields_size = 1; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::GetSessionResp> { + static constexpr const std::size_t fields_size = 3; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::RemoveSessionReq> { + static constexpr const std::size_t fields_size = 1; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::KillQueryReq> { + static constexpr const std::size_t fields_size = 1; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::ReportTaskReq> { + static constexpr const std::size_t fields_size = 4; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::ListClusterInfoResp> { + static constexpr const std::size_t fields_size = 4; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::ListClusterInfoReq> { + static constexpr const std::size_t fields_size = 0; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::GetMetaDirInfoResp> { + static constexpr const std::size_t fields_size = 2; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::GetMetaDirInfoReq> { + static constexpr const std::size_t fields_size = 0; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::VerifyClientVersionResp> { + static constexpr const std::size_t fields_size = 3; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::meta::cpp2::VerifyClientVersionReq> { + static constexpr const std::size_t fields_size = 1; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +}} // apache::thrift diff --git a/src/interface/gen-cpp2/meta_for_each_field.h b/src/interface/gen-cpp2/meta_for_each_field.h new file mode 100644 index 00000000..39f3d5a2 --- /dev/null +++ b/src/interface/gen-cpp2/meta_for_each_field.h @@ -0,0 +1,1632 @@ +/** + * Autogenerated by Thrift for meta.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#pragma once + +#include "meta_metadata.h" +#include + +namespace apache { +namespace thrift { +namespace detail { + +template <> +struct ForEachField<::nebula::meta::cpp2::ID> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).space_id_ref()...); + f(1, static_cast(t).tag_id_ref()...); + f(2, static_cast(t).edge_type_ref()...); + f(3, static_cast(t).index_id_ref()...); + f(4, static_cast(t).cluster_id_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::ColumnTypeDef> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).type_ref()...); + f(1, static_cast(t).type_length_ref()...); + f(2, static_cast(t).geo_shape_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::ColumnDef> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).name_ref()...); + f(1, static_cast(t).type_ref()...); + f(2, static_cast(t).default_value_ref()...); + f(3, static_cast(t).nullable_ref()...); + f(4, static_cast(t).comment_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::SchemaProp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).ttl_duration_ref()...); + f(1, static_cast(t).ttl_col_ref()...); + f(2, static_cast(t).comment_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::Schema> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).columns_ref()...); + f(1, static_cast(t).schema_prop_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::IdName> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).id_ref()...); + f(1, static_cast(t).name_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::SpaceDesc> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).space_name_ref()...); + f(1, static_cast(t).partition_num_ref()...); + f(2, static_cast(t).replica_factor_ref()...); + f(3, static_cast(t).charset_name_ref()...); + f(4, static_cast(t).collate_name_ref()...); + f(5, static_cast(t).vid_type_ref()...); + f(6, static_cast(t).group_name_ref()...); + f(7, static_cast(t).isolation_level_ref()...); + f(8, static_cast(t).comment_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::SpaceItem> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).space_id_ref()...); + f(1, static_cast(t).properties_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::TagItem> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).tag_id_ref()...); + f(1, static_cast(t).tag_name_ref()...); + f(2, static_cast(t).version_ref()...); + f(3, static_cast(t).schema_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::AlterSchemaItem> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).op_ref()...); + f(1, static_cast(t).schema_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::EdgeItem> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).edge_type_ref()...); + f(1, static_cast(t).edge_name_ref()...); + f(2, static_cast(t).version_ref()...); + f(3, static_cast(t).schema_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::IndexItem> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).index_id_ref()...); + f(1, static_cast(t).index_name_ref()...); + f(2, static_cast(t).schema_id_ref()...); + f(3, static_cast(t).schema_name_ref()...); + f(4, static_cast(t).fields_ref()...); + f(5, static_cast(t).comment_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::HostItem> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).hostAddr_ref()...); + f(1, static_cast(t).status_ref()...); + f(2, static_cast(t).leader_parts_ref()...); + f(3, static_cast(t).all_parts_ref()...); + f(4, static_cast(t).role_ref()...); + f(5, static_cast(t).git_info_sha_ref()...); + f(6, static_cast(t).zone_name_ref()...); + f(7, static_cast(t).version_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::UserItem> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).account_ref()...); + f(1, static_cast(t).is_lock_ref()...); + f(2, static_cast(t).max_queries_per_hour_ref()...); + f(3, static_cast(t).max_updates_per_hour_ref()...); + f(4, static_cast(t).max_connections_per_hour_ref()...); + f(5, static_cast(t).max_user_connections_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::RoleItem> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).user_id_ref()...); + f(1, static_cast(t).space_id_ref()...); + f(2, static_cast(t).role_type_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::ExecResp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).code_ref()...); + f(1, static_cast(t).id_ref()...); + f(2, static_cast(t).leader_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::AdminJobReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).op_ref()...); + f(1, static_cast(t).cmd_ref()...); + f(2, static_cast(t).paras_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::JobDesc> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).id_ref()...); + f(1, static_cast(t).cmd_ref()...); + f(2, static_cast(t).paras_ref()...); + f(3, static_cast(t).status_ref()...); + f(4, static_cast(t).start_time_ref()...); + f(5, static_cast(t).stop_time_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::TaskDesc> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).task_id_ref()...); + f(1, static_cast(t).host_ref()...); + f(2, static_cast(t).status_ref()...); + f(3, static_cast(t).start_time_ref()...); + f(4, static_cast(t).stop_time_ref()...); + f(5, static_cast(t).job_id_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::AdminJobResult> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).job_id_ref()...); + f(1, static_cast(t).job_desc_ref()...); + f(2, static_cast(t).task_desc_ref()...); + f(3, static_cast(t).recovered_job_num_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::AdminJobResp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).code_ref()...); + f(1, static_cast(t).leader_ref()...); + f(2, static_cast(t).result_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::Correlativity> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).part_id_ref()...); + f(1, static_cast(t).proportion_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::StatsItem> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).tag_vertices_ref()...); + f(1, static_cast(t).edges_ref()...); + f(2, static_cast(t).space_vertices_ref()...); + f(3, static_cast(t).space_edges_ref()...); + f(4, static_cast(t).positive_part_correlativity_ref()...); + f(5, static_cast(t).negative_part_correlativity_ref()...); + f(6, static_cast(t).status_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::CreateSpaceReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).properties_ref()...); + f(1, static_cast(t).if_not_exists_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::CreateSpaceAsReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).old_space_name_ref()...); + f(1, static_cast(t).new_space_name_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::DropSpaceReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).space_name_ref()...); + f(1, static_cast(t).if_exists_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::ListSpacesReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::ListSpacesResp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).code_ref()...); + f(1, static_cast(t).leader_ref()...); + f(2, static_cast(t).spaces_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::GetSpaceReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).space_name_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::GetSpaceResp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).code_ref()...); + f(1, static_cast(t).leader_ref()...); + f(2, static_cast(t).item_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::CreateTagReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).space_id_ref()...); + f(1, static_cast(t).tag_name_ref()...); + f(2, static_cast(t).schema_ref()...); + f(3, static_cast(t).if_not_exists_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::AlterTagReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).space_id_ref()...); + f(1, static_cast(t).tag_name_ref()...); + f(2, static_cast(t).tag_items_ref()...); + f(3, static_cast(t).schema_prop_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::DropTagReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).space_id_ref()...); + f(1, static_cast(t).tag_name_ref()...); + f(2, static_cast(t).if_exists_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::ListTagsReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).space_id_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::ListTagsResp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).code_ref()...); + f(1, static_cast(t).leader_ref()...); + f(2, static_cast(t).tags_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::GetTagReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).space_id_ref()...); + f(1, static_cast(t).tag_name_ref()...); + f(2, static_cast(t).version_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::GetTagResp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).code_ref()...); + f(1, static_cast(t).leader_ref()...); + f(2, static_cast(t).schema_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::CreateEdgeReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).space_id_ref()...); + f(1, static_cast(t).edge_name_ref()...); + f(2, static_cast(t).schema_ref()...); + f(3, static_cast(t).if_not_exists_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::AlterEdgeReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).space_id_ref()...); + f(1, static_cast(t).edge_name_ref()...); + f(2, static_cast(t).edge_items_ref()...); + f(3, static_cast(t).schema_prop_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::GetEdgeReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).space_id_ref()...); + f(1, static_cast(t).edge_name_ref()...); + f(2, static_cast(t).version_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::GetEdgeResp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).code_ref()...); + f(1, static_cast(t).leader_ref()...); + f(2, static_cast(t).schema_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::DropEdgeReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).space_id_ref()...); + f(1, static_cast(t).edge_name_ref()...); + f(2, static_cast(t).if_exists_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::ListEdgesReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).space_id_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::ListEdgesResp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).code_ref()...); + f(1, static_cast(t).leader_ref()...); + f(2, static_cast(t).edges_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::ListHostsReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).type_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::ListHostsResp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).code_ref()...); + f(1, static_cast(t).leader_ref()...); + f(2, static_cast(t).hosts_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::PartItem> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).part_id_ref()...); + f(1, static_cast(t).leader_ref()...); + f(2, static_cast(t).peers_ref()...); + f(3, static_cast(t).losts_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::ListPartsReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).space_id_ref()...); + f(1, static_cast(t).part_ids_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::ListPartsResp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).code_ref()...); + f(1, static_cast(t).leader_ref()...); + f(2, static_cast(t).parts_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::GetPartsAllocReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).space_id_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::GetPartsAllocResp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).code_ref()...); + f(1, static_cast(t).leader_ref()...); + f(2, static_cast(t).parts_ref()...); + f(3, static_cast(t).terms_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::MultiPutReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).segment_ref()...); + f(1, static_cast(t).pairs_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::GetReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).segment_ref()...); + f(1, static_cast(t).key_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::GetResp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).code_ref()...); + f(1, static_cast(t).leader_ref()...); + f(2, static_cast(t).value_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::MultiGetReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).segment_ref()...); + f(1, static_cast(t).keys_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::MultiGetResp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).code_ref()...); + f(1, static_cast(t).leader_ref()...); + f(2, static_cast(t).values_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::RemoveReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).segment_ref()...); + f(1, static_cast(t).key_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::RemoveRangeReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).segment_ref()...); + f(1, static_cast(t).start_ref()...); + f(2, static_cast(t).end_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::ScanReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).segment_ref()...); + f(1, static_cast(t).start_ref()...); + f(2, static_cast(t).end_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::ScanResp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).code_ref()...); + f(1, static_cast(t).leader_ref()...); + f(2, static_cast(t).values_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::HBResp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).code_ref()...); + f(1, static_cast(t).leader_ref()...); + f(2, static_cast(t).cluster_id_ref()...); + f(3, static_cast(t).last_update_time_in_ms_ref()...); + f(4, static_cast(t).meta_version_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::LeaderInfo> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).part_id_ref()...); + f(1, static_cast(t).term_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::HBReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).role_ref()...); + f(1, static_cast(t).host_ref()...); + f(2, static_cast(t).cluster_id_ref()...); + f(3, static_cast(t).leader_partIds_ref()...); + f(4, static_cast(t).git_info_sha_ref()...); + f(5, static_cast(t).version_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::IndexFieldDef> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).name_ref()...); + f(1, static_cast(t).type_length_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::CreateTagIndexReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).space_id_ref()...); + f(1, static_cast(t).index_name_ref()...); + f(2, static_cast(t).tag_name_ref()...); + f(3, static_cast(t).fields_ref()...); + f(4, static_cast(t).if_not_exists_ref()...); + f(5, static_cast(t).comment_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::DropTagIndexReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).space_id_ref()...); + f(1, static_cast(t).index_name_ref()...); + f(2, static_cast(t).if_exists_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::GetTagIndexReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).space_id_ref()...); + f(1, static_cast(t).index_name_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::GetTagIndexResp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).code_ref()...); + f(1, static_cast(t).leader_ref()...); + f(2, static_cast(t).item_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::ListTagIndexesReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).space_id_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::ListTagIndexesResp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).code_ref()...); + f(1, static_cast(t).leader_ref()...); + f(2, static_cast(t).items_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::CreateEdgeIndexReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).space_id_ref()...); + f(1, static_cast(t).index_name_ref()...); + f(2, static_cast(t).edge_name_ref()...); + f(3, static_cast(t).fields_ref()...); + f(4, static_cast(t).if_not_exists_ref()...); + f(5, static_cast(t).comment_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::DropEdgeIndexReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).space_id_ref()...); + f(1, static_cast(t).index_name_ref()...); + f(2, static_cast(t).if_exists_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::GetEdgeIndexReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).space_id_ref()...); + f(1, static_cast(t).index_name_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::GetEdgeIndexResp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).code_ref()...); + f(1, static_cast(t).leader_ref()...); + f(2, static_cast(t).item_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::ListEdgeIndexesReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).space_id_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::ListEdgeIndexesResp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).code_ref()...); + f(1, static_cast(t).leader_ref()...); + f(2, static_cast(t).items_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::RebuildIndexReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).space_id_ref()...); + f(1, static_cast(t).index_name_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::CreateUserReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).account_ref()...); + f(1, static_cast(t).encoded_pwd_ref()...); + f(2, static_cast(t).if_not_exists_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::DropUserReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).account_ref()...); + f(1, static_cast(t).if_exists_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::AlterUserReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).account_ref()...); + f(1, static_cast(t).encoded_pwd_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::GrantRoleReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).role_item_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::RevokeRoleReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).role_item_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::ListUsersReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::ListUsersResp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).code_ref()...); + f(1, static_cast(t).leader_ref()...); + f(2, static_cast(t).users_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::ListRolesReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).space_id_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::ListRolesResp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).code_ref()...); + f(1, static_cast(t).leader_ref()...); + f(2, static_cast(t).roles_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::GetUserRolesReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).account_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::ChangePasswordReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).account_ref()...); + f(1, static_cast(t).new_encoded_pwd_ref()...); + f(2, static_cast(t).old_encoded_pwd_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::BalanceReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).space_id_ref()...); + f(1, static_cast(t).id_ref()...); + f(2, static_cast(t).host_del_ref()...); + f(3, static_cast(t).stop_ref()...); + f(4, static_cast(t).reset_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::BalanceTask> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).id_ref()...); + f(1, static_cast(t).result_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::BalanceResp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).code_ref()...); + f(1, static_cast(t).id_ref()...); + f(2, static_cast(t).leader_ref()...); + f(3, static_cast(t).tasks_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::LeaderBalanceReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::ConfigItem> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).module_ref()...); + f(1, static_cast(t).name_ref()...); + f(2, static_cast(t).mode_ref()...); + f(3, static_cast(t).value_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::RegConfigReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).items_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::GetConfigReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).item_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::GetConfigResp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).code_ref()...); + f(1, static_cast(t).leader_ref()...); + f(2, static_cast(t).items_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::SetConfigReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).item_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::ListConfigsReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).space_ref()...); + f(1, static_cast(t).module_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::ListConfigsResp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).code_ref()...); + f(1, static_cast(t).leader_ref()...); + f(2, static_cast(t).items_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::CreateSnapshotReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::DropSnapshotReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).name_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::ListSnapshotsReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::Snapshot> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).name_ref()...); + f(1, static_cast(t).status_ref()...); + f(2, static_cast(t).hosts_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::ListSnapshotsResp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).code_ref()...); + f(1, static_cast(t).leader_ref()...); + f(2, static_cast(t).snapshots_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::ListIndexStatusReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).space_id_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::IndexStatus> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).name_ref()...); + f(1, static_cast(t).status_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::ListIndexStatusResp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).code_ref()...); + f(1, static_cast(t).leader_ref()...); + f(2, static_cast(t).statuses_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::AddZoneReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).zone_name_ref()...); + f(1, static_cast(t).nodes_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::DropZoneReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).zone_name_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::AddHostIntoZoneReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).node_ref()...); + f(1, static_cast(t).zone_name_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::DropHostFromZoneReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).node_ref()...); + f(1, static_cast(t).zone_name_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::GetZoneReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).zone_name_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::GetZoneResp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).code_ref()...); + f(1, static_cast(t).leader_ref()...); + f(2, static_cast(t).hosts_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::ListZonesReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::Zone> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).zone_name_ref()...); + f(1, static_cast(t).nodes_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::ListZonesResp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).code_ref()...); + f(1, static_cast(t).leader_ref()...); + f(2, static_cast(t).zones_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::AddGroupReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).group_name_ref()...); + f(1, static_cast(t).zone_names_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::DropGroupReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).group_name_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::AddZoneIntoGroupReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).zone_name_ref()...); + f(1, static_cast(t).group_name_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::DropZoneFromGroupReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).zone_name_ref()...); + f(1, static_cast(t).group_name_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::GetGroupReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).group_name_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::GetGroupResp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).code_ref()...); + f(1, static_cast(t).leader_ref()...); + f(2, static_cast(t).zone_names_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::ListGroupsReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::Group> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).group_name_ref()...); + f(1, static_cast(t).zone_names_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::ListGroupsResp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).code_ref()...); + f(1, static_cast(t).leader_ref()...); + f(2, static_cast(t).groups_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::AddListenerReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).space_id_ref()...); + f(1, static_cast(t).type_ref()...); + f(2, static_cast(t).hosts_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::RemoveListenerReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).space_id_ref()...); + f(1, static_cast(t).type_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::ListListenerReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).space_id_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::ListenerInfo> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).type_ref()...); + f(1, static_cast(t).host_ref()...); + f(2, static_cast(t).part_id_ref()...); + f(3, static_cast(t).status_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::ListListenerResp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).code_ref()...); + f(1, static_cast(t).leader_ref()...); + f(2, static_cast(t).listeners_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::GetStatsReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).space_id_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::GetStatsResp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).code_ref()...); + f(1, static_cast(t).leader_ref()...); + f(2, static_cast(t).stats_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::BackupInfo> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).host_ref()...); + f(1, static_cast(t).info_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::SpaceBackupInfo> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).space_ref()...); + f(1, static_cast(t).info_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::BackupMeta> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).backup_info_ref()...); + f(1, static_cast(t).meta_files_ref()...); + f(2, static_cast(t).backup_name_ref()...); + f(3, static_cast(t).full_ref()...); + f(4, static_cast(t).include_system_space_ref()...); + f(5, static_cast(t).create_time_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::CreateBackupReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).spaces_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::CreateBackupResp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).code_ref()...); + f(1, static_cast(t).leader_ref()...); + f(2, static_cast(t).meta_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::HostPair> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).from_host_ref()...); + f(1, static_cast(t).to_host_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::RestoreMetaReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).files_ref()...); + f(1, static_cast(t).hosts_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::FTClient> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).host_ref()...); + f(1, static_cast(t).user_ref()...); + f(2, static_cast(t).pwd_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::SignInFTServiceReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).type_ref()...); + f(1, static_cast(t).clients_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::SignOutFTServiceReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::ListFTClientsReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::ListFTClientsResp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).code_ref()...); + f(1, static_cast(t).leader_ref()...); + f(2, static_cast(t).clients_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::FTIndex> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).space_id_ref()...); + f(1, static_cast(t).depend_schema_ref()...); + f(2, static_cast(t).fields_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::CreateFTIndexReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).fulltext_index_name_ref()...); + f(1, static_cast(t).index_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::DropFTIndexReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).space_id_ref()...); + f(1, static_cast(t).fulltext_index_name_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::ListFTIndexesReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::ListFTIndexesResp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).code_ref()...); + f(1, static_cast(t).leader_ref()...); + f(2, static_cast(t).indexes_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::QueryDesc> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).start_time_ref()...); + f(1, static_cast(t).status_ref()...); + f(2, static_cast(t).duration_ref()...); + f(3, static_cast(t).query_ref()...); + f(4, static_cast(t).graph_addr_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::Session> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).session_id_ref()...); + f(1, static_cast(t).create_time_ref()...); + f(2, static_cast(t).update_time_ref()...); + f(3, static_cast(t).user_name_ref()...); + f(4, static_cast(t).space_name_ref()...); + f(5, static_cast(t).graph_addr_ref()...); + f(6, static_cast(t).timezone_ref()...); + f(7, static_cast(t).client_ip_ref()...); + f(8, static_cast(t).configs_ref()...); + f(9, static_cast(t).queries_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::CreateSessionReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).user_ref()...); + f(1, static_cast(t).graph_addr_ref()...); + f(2, static_cast(t).client_ip_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::CreateSessionResp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).code_ref()...); + f(1, static_cast(t).leader_ref()...); + f(2, static_cast(t).session_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::UpdateSessionsReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).sessions_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::UpdateSessionsResp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).code_ref()...); + f(1, static_cast(t).leader_ref()...); + f(2, static_cast(t).killed_queries_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::ListSessionsReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::ListSessionsResp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).code_ref()...); + f(1, static_cast(t).leader_ref()...); + f(2, static_cast(t).sessions_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::GetSessionReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).session_id_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::GetSessionResp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).code_ref()...); + f(1, static_cast(t).leader_ref()...); + f(2, static_cast(t).session_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::RemoveSessionReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).session_id_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::KillQueryReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).kill_queries_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::ReportTaskReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).code_ref()...); + f(1, static_cast(t).job_id_ref()...); + f(2, static_cast(t).task_id_ref()...); + f(3, static_cast(t).stats_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::ListClusterInfoResp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).code_ref()...); + f(1, static_cast(t).leader_ref()...); + f(2, static_cast(t).meta_servers_ref()...); + f(3, static_cast(t).storage_servers_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::ListClusterInfoReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::GetMetaDirInfoResp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).code_ref()...); + f(1, static_cast(t).dir_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::GetMetaDirInfoReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::VerifyClientVersionResp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).code_ref()...); + f(1, static_cast(t).leader_ref()...); + f(2, static_cast(t).error_msg_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::meta::cpp2::VerifyClientVersionReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).version_ref()...); + } +}; +} // namespace detail +} // namespace thrift +} // namespace apache diff --git a/src/interface/gen-cpp2/meta_metadata.cpp b/src/interface/gen-cpp2/meta_metadata.cpp new file mode 100644 index 00000000..a62c4d6c --- /dev/null +++ b/src/interface/gen-cpp2/meta_metadata.cpp @@ -0,0 +1,5934 @@ +/** + * Autogenerated by Thrift for meta.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#include +#include "meta_metadata.h" + +namespace apache { +namespace thrift { +namespace detail { +namespace md { +using ThriftMetadata = ::apache::thrift::metadata::ThriftMetadata; +using ThriftPrimitiveType = ::apache::thrift::metadata::ThriftPrimitiveType; +using ThriftType = ::apache::thrift::metadata::ThriftType; +using ThriftService = ::apache::thrift::metadata::ThriftService; +using ThriftServiceContext = ::apache::thrift::metadata::ThriftServiceContext; +using ThriftFunctionGenerator = void (*)(ThriftMetadata&, ThriftService&); + +void EnumMetadata<::nebula::meta::cpp2::AlterSchemaOp>::gen(ThriftMetadata& metadata) { + auto res = metadata.enums_ref()->emplace("meta.AlterSchemaOp", ::apache::thrift::metadata::ThriftEnum{}); + if (!res.second) { + return; + } + ::apache::thrift::metadata::ThriftEnum& enum_metadata = res.first->second; + enum_metadata.name_ref() = "meta.AlterSchemaOp"; + using EnumTraits = TEnumTraits<::nebula::meta::cpp2::AlterSchemaOp>; + for (std::size_t i = 0; i < EnumTraits::size; ++i) { + enum_metadata.elements_ref()->emplace(static_cast(EnumTraits::values[i]), EnumTraits::names[i].str()); + } +} +void EnumMetadata<::nebula::meta::cpp2::RoleType>::gen(ThriftMetadata& metadata) { + auto res = metadata.enums_ref()->emplace("meta.RoleType", ::apache::thrift::metadata::ThriftEnum{}); + if (!res.second) { + return; + } + ::apache::thrift::metadata::ThriftEnum& enum_metadata = res.first->second; + enum_metadata.name_ref() = "meta.RoleType"; + using EnumTraits = TEnumTraits<::nebula::meta::cpp2::RoleType>; + for (std::size_t i = 0; i < EnumTraits::size; ++i) { + enum_metadata.elements_ref()->emplace(static_cast(EnumTraits::values[i]), EnumTraits::names[i].str()); + } +} +void EnumMetadata<::nebula::meta::cpp2::GeoShape>::gen(ThriftMetadata& metadata) { + auto res = metadata.enums_ref()->emplace("meta.GeoShape", ::apache::thrift::metadata::ThriftEnum{}); + if (!res.second) { + return; + } + ::apache::thrift::metadata::ThriftEnum& enum_metadata = res.first->second; + enum_metadata.name_ref() = "meta.GeoShape"; + using EnumTraits = TEnumTraits<::nebula::meta::cpp2::GeoShape>; + for (std::size_t i = 0; i < EnumTraits::size; ++i) { + enum_metadata.elements_ref()->emplace(static_cast(EnumTraits::values[i]), EnumTraits::names[i].str()); + } +} +void EnumMetadata<::nebula::meta::cpp2::PropertyType>::gen(ThriftMetadata& metadata) { + auto res = metadata.enums_ref()->emplace("meta.PropertyType", ::apache::thrift::metadata::ThriftEnum{}); + if (!res.second) { + return; + } + ::apache::thrift::metadata::ThriftEnum& enum_metadata = res.first->second; + enum_metadata.name_ref() = "meta.PropertyType"; + using EnumTraits = TEnumTraits<::nebula::meta::cpp2::PropertyType>; + for (std::size_t i = 0; i < EnumTraits::size; ++i) { + enum_metadata.elements_ref()->emplace(static_cast(EnumTraits::values[i]), EnumTraits::names[i].str()); + } +} +void EnumMetadata<::nebula::meta::cpp2::IsolationLevel>::gen(ThriftMetadata& metadata) { + auto res = metadata.enums_ref()->emplace("meta.IsolationLevel", ::apache::thrift::metadata::ThriftEnum{}); + if (!res.second) { + return; + } + ::apache::thrift::metadata::ThriftEnum& enum_metadata = res.first->second; + enum_metadata.name_ref() = "meta.IsolationLevel"; + using EnumTraits = TEnumTraits<::nebula::meta::cpp2::IsolationLevel>; + for (std::size_t i = 0; i < EnumTraits::size; ++i) { + enum_metadata.elements_ref()->emplace(static_cast(EnumTraits::values[i]), EnumTraits::names[i].str()); + } +} +void EnumMetadata<::nebula::meta::cpp2::HostStatus>::gen(ThriftMetadata& metadata) { + auto res = metadata.enums_ref()->emplace("meta.HostStatus", ::apache::thrift::metadata::ThriftEnum{}); + if (!res.second) { + return; + } + ::apache::thrift::metadata::ThriftEnum& enum_metadata = res.first->second; + enum_metadata.name_ref() = "meta.HostStatus"; + using EnumTraits = TEnumTraits<::nebula::meta::cpp2::HostStatus>; + for (std::size_t i = 0; i < EnumTraits::size; ++i) { + enum_metadata.elements_ref()->emplace(static_cast(EnumTraits::values[i]), EnumTraits::names[i].str()); + } +} +void EnumMetadata<::nebula::meta::cpp2::SnapshotStatus>::gen(ThriftMetadata& metadata) { + auto res = metadata.enums_ref()->emplace("meta.SnapshotStatus", ::apache::thrift::metadata::ThriftEnum{}); + if (!res.second) { + return; + } + ::apache::thrift::metadata::ThriftEnum& enum_metadata = res.first->second; + enum_metadata.name_ref() = "meta.SnapshotStatus"; + using EnumTraits = TEnumTraits<::nebula::meta::cpp2::SnapshotStatus>; + for (std::size_t i = 0; i < EnumTraits::size; ++i) { + enum_metadata.elements_ref()->emplace(static_cast(EnumTraits::values[i]), EnumTraits::names[i].str()); + } +} +void EnumMetadata<::nebula::meta::cpp2::AdminJobOp>::gen(ThriftMetadata& metadata) { + auto res = metadata.enums_ref()->emplace("meta.AdminJobOp", ::apache::thrift::metadata::ThriftEnum{}); + if (!res.second) { + return; + } + ::apache::thrift::metadata::ThriftEnum& enum_metadata = res.first->second; + enum_metadata.name_ref() = "meta.AdminJobOp"; + using EnumTraits = TEnumTraits<::nebula::meta::cpp2::AdminJobOp>; + for (std::size_t i = 0; i < EnumTraits::size; ++i) { + enum_metadata.elements_ref()->emplace(static_cast(EnumTraits::values[i]), EnumTraits::names[i].str()); + } +} +void EnumMetadata<::nebula::meta::cpp2::AdminCmd>::gen(ThriftMetadata& metadata) { + auto res = metadata.enums_ref()->emplace("meta.AdminCmd", ::apache::thrift::metadata::ThriftEnum{}); + if (!res.second) { + return; + } + ::apache::thrift::metadata::ThriftEnum& enum_metadata = res.first->second; + enum_metadata.name_ref() = "meta.AdminCmd"; + using EnumTraits = TEnumTraits<::nebula::meta::cpp2::AdminCmd>; + for (std::size_t i = 0; i < EnumTraits::size; ++i) { + enum_metadata.elements_ref()->emplace(static_cast(EnumTraits::values[i]), EnumTraits::names[i].str()); + } +} +void EnumMetadata<::nebula::meta::cpp2::JobStatus>::gen(ThriftMetadata& metadata) { + auto res = metadata.enums_ref()->emplace("meta.JobStatus", ::apache::thrift::metadata::ThriftEnum{}); + if (!res.second) { + return; + } + ::apache::thrift::metadata::ThriftEnum& enum_metadata = res.first->second; + enum_metadata.name_ref() = "meta.JobStatus"; + using EnumTraits = TEnumTraits<::nebula::meta::cpp2::JobStatus>; + for (std::size_t i = 0; i < EnumTraits::size; ++i) { + enum_metadata.elements_ref()->emplace(static_cast(EnumTraits::values[i]), EnumTraits::names[i].str()); + } +} +void EnumMetadata<::nebula::meta::cpp2::ListHostType>::gen(ThriftMetadata& metadata) { + auto res = metadata.enums_ref()->emplace("meta.ListHostType", ::apache::thrift::metadata::ThriftEnum{}); + if (!res.second) { + return; + } + ::apache::thrift::metadata::ThriftEnum& enum_metadata = res.first->second; + enum_metadata.name_ref() = "meta.ListHostType"; + using EnumTraits = TEnumTraits<::nebula::meta::cpp2::ListHostType>; + for (std::size_t i = 0; i < EnumTraits::size; ++i) { + enum_metadata.elements_ref()->emplace(static_cast(EnumTraits::values[i]), EnumTraits::names[i].str()); + } +} +void EnumMetadata<::nebula::meta::cpp2::HostRole>::gen(ThriftMetadata& metadata) { + auto res = metadata.enums_ref()->emplace("meta.HostRole", ::apache::thrift::metadata::ThriftEnum{}); + if (!res.second) { + return; + } + ::apache::thrift::metadata::ThriftEnum& enum_metadata = res.first->second; + enum_metadata.name_ref() = "meta.HostRole"; + using EnumTraits = TEnumTraits<::nebula::meta::cpp2::HostRole>; + for (std::size_t i = 0; i < EnumTraits::size; ++i) { + enum_metadata.elements_ref()->emplace(static_cast(EnumTraits::values[i]), EnumTraits::names[i].str()); + } +} +void EnumMetadata<::nebula::meta::cpp2::TaskResult>::gen(ThriftMetadata& metadata) { + auto res = metadata.enums_ref()->emplace("meta.TaskResult", ::apache::thrift::metadata::ThriftEnum{}); + if (!res.second) { + return; + } + ::apache::thrift::metadata::ThriftEnum& enum_metadata = res.first->second; + enum_metadata.name_ref() = "meta.TaskResult"; + using EnumTraits = TEnumTraits<::nebula::meta::cpp2::TaskResult>; + for (std::size_t i = 0; i < EnumTraits::size; ++i) { + enum_metadata.elements_ref()->emplace(static_cast(EnumTraits::values[i]), EnumTraits::names[i].str()); + } +} +void EnumMetadata<::nebula::meta::cpp2::ConfigModule>::gen(ThriftMetadata& metadata) { + auto res = metadata.enums_ref()->emplace("meta.ConfigModule", ::apache::thrift::metadata::ThriftEnum{}); + if (!res.second) { + return; + } + ::apache::thrift::metadata::ThriftEnum& enum_metadata = res.first->second; + enum_metadata.name_ref() = "meta.ConfigModule"; + using EnumTraits = TEnumTraits<::nebula::meta::cpp2::ConfigModule>; + for (std::size_t i = 0; i < EnumTraits::size; ++i) { + enum_metadata.elements_ref()->emplace(static_cast(EnumTraits::values[i]), EnumTraits::names[i].str()); + } +} +void EnumMetadata<::nebula::meta::cpp2::ConfigMode>::gen(ThriftMetadata& metadata) { + auto res = metadata.enums_ref()->emplace("meta.ConfigMode", ::apache::thrift::metadata::ThriftEnum{}); + if (!res.second) { + return; + } + ::apache::thrift::metadata::ThriftEnum& enum_metadata = res.first->second; + enum_metadata.name_ref() = "meta.ConfigMode"; + using EnumTraits = TEnumTraits<::nebula::meta::cpp2::ConfigMode>; + for (std::size_t i = 0; i < EnumTraits::size; ++i) { + enum_metadata.elements_ref()->emplace(static_cast(EnumTraits::values[i]), EnumTraits::names[i].str()); + } +} +void EnumMetadata<::nebula::meta::cpp2::ListenerType>::gen(ThriftMetadata& metadata) { + auto res = metadata.enums_ref()->emplace("meta.ListenerType", ::apache::thrift::metadata::ThriftEnum{}); + if (!res.second) { + return; + } + ::apache::thrift::metadata::ThriftEnum& enum_metadata = res.first->second; + enum_metadata.name_ref() = "meta.ListenerType"; + using EnumTraits = TEnumTraits<::nebula::meta::cpp2::ListenerType>; + for (std::size_t i = 0; i < EnumTraits::size; ++i) { + enum_metadata.elements_ref()->emplace(static_cast(EnumTraits::values[i]), EnumTraits::names[i].str()); + } +} +void EnumMetadata<::nebula::meta::cpp2::FTServiceType>::gen(ThriftMetadata& metadata) { + auto res = metadata.enums_ref()->emplace("meta.FTServiceType", ::apache::thrift::metadata::ThriftEnum{}); + if (!res.second) { + return; + } + ::apache::thrift::metadata::ThriftEnum& enum_metadata = res.first->second; + enum_metadata.name_ref() = "meta.FTServiceType"; + using EnumTraits = TEnumTraits<::nebula::meta::cpp2::FTServiceType>; + for (std::size_t i = 0; i < EnumTraits::size; ++i) { + enum_metadata.elements_ref()->emplace(static_cast(EnumTraits::values[i]), EnumTraits::names[i].str()); + } +} +void EnumMetadata<::nebula::meta::cpp2::QueryStatus>::gen(ThriftMetadata& metadata) { + auto res = metadata.enums_ref()->emplace("meta.QueryStatus", ::apache::thrift::metadata::ThriftEnum{}); + if (!res.second) { + return; + } + ::apache::thrift::metadata::ThriftEnum& enum_metadata = res.first->second; + enum_metadata.name_ref() = "meta.QueryStatus"; + using EnumTraits = TEnumTraits<::nebula::meta::cpp2::QueryStatus>; + for (std::size_t i = 0; i < EnumTraits::size; ++i) { + enum_metadata.elements_ref()->emplace(static_cast(EnumTraits::values[i]), EnumTraits::names[i].str()); + } +} + +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::ID>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.ID", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_ID = res.first->second; + meta_ID.name_ref() = "meta.ID"; + meta_ID.is_union_ref() = true; + static const EncodedThriftField + meta_ID_fields[] = { + std::make_tuple(1, "space_id", false, std::make_unique("common.GraphSpaceID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + std::make_tuple(2, "tag_id", false, std::make_unique("common.TagID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + std::make_tuple(3, "edge_type", false, std::make_unique("common.EdgeType", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + std::make_tuple(4, "index_id", false, std::make_unique("common.IndexID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + std::make_tuple(5, "cluster_id", false, std::make_unique("meta.ClusterID", std::make_unique(ThriftPrimitiveType::THRIFT_I64_TYPE)), std::vector{}), + }; + for (const auto& f : meta_ID_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_ID.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::ColumnTypeDef>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.ColumnTypeDef", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_ColumnTypeDef = res.first->second; + meta_ColumnTypeDef.name_ref() = "meta.ColumnTypeDef"; + meta_ColumnTypeDef.is_union_ref() = false; + static const EncodedThriftField + meta_ColumnTypeDef_fields[] = { + std::make_tuple(1, "type", false, std::make_unique>("meta.PropertyType"), std::vector{}), + std::make_tuple(2, "type_length", true, std::make_unique(ThriftPrimitiveType::THRIFT_I16_TYPE), std::vector{}), + std::make_tuple(3, "geo_shape", true, std::make_unique>("meta.GeoShape"), std::vector{}), + }; + for (const auto& f : meta_ColumnTypeDef_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_ColumnTypeDef.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::ColumnDef>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.ColumnDef", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_ColumnDef = res.first->second; + meta_ColumnDef.name_ref() = "meta.ColumnDef"; + meta_ColumnDef.is_union_ref() = false; + static const EncodedThriftField + meta_ColumnDef_fields[] = { + std::make_tuple(1, "name", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + std::make_tuple(2, "type", false, std::make_unique>("meta.ColumnTypeDef"), std::vector{}), + std::make_tuple(3, "default_value", true, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + std::make_tuple(4, "nullable", true, std::make_unique(ThriftPrimitiveType::THRIFT_BOOL_TYPE), std::vector{}), + std::make_tuple(5, "comment", true, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + }; + for (const auto& f : meta_ColumnDef_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_ColumnDef.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::SchemaProp>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.SchemaProp", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_SchemaProp = res.first->second; + meta_SchemaProp.name_ref() = "meta.SchemaProp"; + meta_SchemaProp.is_union_ref() = false; + static const EncodedThriftField + meta_SchemaProp_fields[] = { + std::make_tuple(1, "ttl_duration", true, std::make_unique(ThriftPrimitiveType::THRIFT_I64_TYPE), std::vector{}), + std::make_tuple(2, "ttl_col", true, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + std::make_tuple(3, "comment", true, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + }; + for (const auto& f : meta_SchemaProp_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_SchemaProp.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::Schema>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.Schema", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_Schema = res.first->second; + meta_Schema.name_ref() = "meta.Schema"; + meta_Schema.is_union_ref() = false; + static const EncodedThriftField + meta_Schema_fields[] = { + std::make_tuple(1, "columns", false, std::make_unique(std::make_unique>("meta.ColumnDef")), std::vector{}), + std::make_tuple(2, "schema_prop", false, std::make_unique>("meta.SchemaProp"), std::vector{}), + }; + for (const auto& f : meta_Schema_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_Schema.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::IdName>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.IdName", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_IdName = res.first->second; + meta_IdName.name_ref() = "meta.IdName"; + meta_IdName.is_union_ref() = false; + static const EncodedThriftField + meta_IdName_fields[] = { + std::make_tuple(1, "id", false, std::make_unique>("meta.ID"), std::vector{}), + std::make_tuple(2, "name", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + }; + for (const auto& f : meta_IdName_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_IdName.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::SpaceDesc>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.SpaceDesc", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_SpaceDesc = res.first->second; + meta_SpaceDesc.name_ref() = "meta.SpaceDesc"; + meta_SpaceDesc.is_union_ref() = false; + static const EncodedThriftField + meta_SpaceDesc_fields[] = { + std::make_tuple(1, "space_name", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + std::make_tuple(2, "partition_num", false, std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE), std::vector{}), + std::make_tuple(3, "replica_factor", false, std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE), std::vector{}), + std::make_tuple(4, "charset_name", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + std::make_tuple(5, "collate_name", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + std::make_tuple(6, "vid_type", false, std::make_unique>("meta.ColumnTypeDef"), std::vector{}), + std::make_tuple(7, "group_name", true, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + std::make_tuple(8, "isolation_level", true, std::make_unique>("meta.IsolationLevel"), std::vector{}), + std::make_tuple(9, "comment", true, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + }; + for (const auto& f : meta_SpaceDesc_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_SpaceDesc.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::SpaceItem>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.SpaceItem", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_SpaceItem = res.first->second; + meta_SpaceItem.name_ref() = "meta.SpaceItem"; + meta_SpaceItem.is_union_ref() = false; + static const EncodedThriftField + meta_SpaceItem_fields[] = { + std::make_tuple(1, "space_id", false, std::make_unique("common.GraphSpaceID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + std::make_tuple(2, "properties", false, std::make_unique>("meta.SpaceDesc"), std::vector{}), + }; + for (const auto& f : meta_SpaceItem_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_SpaceItem.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::TagItem>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.TagItem", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_TagItem = res.first->second; + meta_TagItem.name_ref() = "meta.TagItem"; + meta_TagItem.is_union_ref() = false; + static const EncodedThriftField + meta_TagItem_fields[] = { + std::make_tuple(1, "tag_id", false, std::make_unique("common.TagID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + std::make_tuple(2, "tag_name", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + std::make_tuple(3, "version", false, std::make_unique("meta.SchemaVer", std::make_unique(ThriftPrimitiveType::THRIFT_I64_TYPE)), std::vector{}), + std::make_tuple(4, "schema", false, std::make_unique>("meta.Schema"), std::vector{}), + }; + for (const auto& f : meta_TagItem_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_TagItem.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::AlterSchemaItem>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.AlterSchemaItem", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_AlterSchemaItem = res.first->second; + meta_AlterSchemaItem.name_ref() = "meta.AlterSchemaItem"; + meta_AlterSchemaItem.is_union_ref() = false; + static const EncodedThriftField + meta_AlterSchemaItem_fields[] = { + std::make_tuple(1, "op", false, std::make_unique>("meta.AlterSchemaOp"), std::vector{}), + std::make_tuple(2, "schema", false, std::make_unique>("meta.Schema"), std::vector{}), + }; + for (const auto& f : meta_AlterSchemaItem_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_AlterSchemaItem.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::EdgeItem>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.EdgeItem", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_EdgeItem = res.first->second; + meta_EdgeItem.name_ref() = "meta.EdgeItem"; + meta_EdgeItem.is_union_ref() = false; + static const EncodedThriftField + meta_EdgeItem_fields[] = { + std::make_tuple(1, "edge_type", false, std::make_unique("common.EdgeType", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + std::make_tuple(2, "edge_name", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + std::make_tuple(3, "version", false, std::make_unique("meta.SchemaVer", std::make_unique(ThriftPrimitiveType::THRIFT_I64_TYPE)), std::vector{}), + std::make_tuple(4, "schema", false, std::make_unique>("meta.Schema"), std::vector{}), + }; + for (const auto& f : meta_EdgeItem_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_EdgeItem.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::IndexItem>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.IndexItem", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_IndexItem = res.first->second; + meta_IndexItem.name_ref() = "meta.IndexItem"; + meta_IndexItem.is_union_ref() = false; + static const EncodedThriftField + meta_IndexItem_fields[] = { + std::make_tuple(1, "index_id", false, std::make_unique("common.IndexID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + std::make_tuple(2, "index_name", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + std::make_tuple(3, "schema_id", false, std::make_unique>("common.SchemaID"), std::vector{}), + std::make_tuple(4, "schema_name", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + std::make_tuple(5, "fields", false, std::make_unique(std::make_unique>("meta.ColumnDef")), std::vector{}), + std::make_tuple(6, "comment", true, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + }; + for (const auto& f : meta_IndexItem_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_IndexItem.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::HostItem>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.HostItem", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_HostItem = res.first->second; + meta_HostItem.name_ref() = "meta.HostItem"; + meta_HostItem.is_union_ref() = false; + static const EncodedThriftField + meta_HostItem_fields[] = { + std::make_tuple(1, "hostAddr", false, std::make_unique>("common.HostAddr"), std::vector{}), + std::make_tuple(2, "status", false, std::make_unique>("meta.HostStatus"), std::vector{}), + std::make_tuple(3, "leader_parts", false, std::make_unique(std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::make_unique(std::make_unique("common.PartitionID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)))), std::vector{}), + std::make_tuple(4, "all_parts", false, std::make_unique(std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::make_unique(std::make_unique("common.PartitionID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)))), std::vector{}), + std::make_tuple(5, "role", false, std::make_unique("meta.HostRole", std::make_unique>("meta.HostRole")), std::vector{}), + std::make_tuple(6, "git_info_sha", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + std::make_tuple(7, "zone_name", true, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + std::make_tuple(8, "version", true, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + }; + for (const auto& f : meta_HostItem_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_HostItem.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::UserItem>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.UserItem", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_UserItem = res.first->second; + meta_UserItem.name_ref() = "meta.UserItem"; + meta_UserItem.is_union_ref() = false; + static const EncodedThriftField + meta_UserItem_fields[] = { + std::make_tuple(1, "account", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + std::make_tuple(2, "is_lock", false, std::make_unique(ThriftPrimitiveType::THRIFT_BOOL_TYPE), std::vector{}), + std::make_tuple(3, "max_queries_per_hour", false, std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE), std::vector{}), + std::make_tuple(4, "max_updates_per_hour", false, std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE), std::vector{}), + std::make_tuple(5, "max_connections_per_hour", false, std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE), std::vector{}), + std::make_tuple(6, "max_user_connections", false, std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE), std::vector{}), + }; + for (const auto& f : meta_UserItem_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_UserItem.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::RoleItem>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.RoleItem", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_RoleItem = res.first->second; + meta_RoleItem.name_ref() = "meta.RoleItem"; + meta_RoleItem.is_union_ref() = false; + static const EncodedThriftField + meta_RoleItem_fields[] = { + std::make_tuple(1, "user_id", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + std::make_tuple(2, "space_id", false, std::make_unique("common.GraphSpaceID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + std::make_tuple(3, "role_type", false, std::make_unique>("meta.RoleType"), std::vector{}), + }; + for (const auto& f : meta_RoleItem_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_RoleItem.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::ExecResp>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.ExecResp", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_ExecResp = res.first->second; + meta_ExecResp.name_ref() = "meta.ExecResp"; + meta_ExecResp.is_union_ref() = false; + static const EncodedThriftField + meta_ExecResp_fields[] = { + std::make_tuple(1, "code", false, std::make_unique>("common.ErrorCode"), std::vector{}), + std::make_tuple(2, "id", false, std::make_unique>("meta.ID"), std::vector{}), + std::make_tuple(3, "leader", false, std::make_unique>("common.HostAddr"), std::vector{}), + }; + for (const auto& f : meta_ExecResp_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_ExecResp.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::AdminJobReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.AdminJobReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_AdminJobReq = res.first->second; + meta_AdminJobReq.name_ref() = "meta.AdminJobReq"; + meta_AdminJobReq.is_union_ref() = false; + static const EncodedThriftField + meta_AdminJobReq_fields[] = { + std::make_tuple(1, "op", false, std::make_unique>("meta.AdminJobOp"), std::vector{}), + std::make_tuple(2, "cmd", false, std::make_unique("meta.AdminCmd", std::make_unique>("meta.AdminCmd")), std::vector{}), + std::make_tuple(3, "paras", false, std::make_unique(std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE)), std::vector{}), + }; + for (const auto& f : meta_AdminJobReq_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_AdminJobReq.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::JobDesc>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.JobDesc", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_JobDesc = res.first->second; + meta_JobDesc.name_ref() = "meta.JobDesc"; + meta_JobDesc.is_union_ref() = false; + static const EncodedThriftField + meta_JobDesc_fields[] = { + std::make_tuple(1, "id", false, std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE), std::vector{}), + std::make_tuple(2, "cmd", false, std::make_unique>("meta.AdminCmd"), std::vector{}), + std::make_tuple(3, "paras", false, std::make_unique(std::make_unique(ThriftPrimitiveType::THRIFT_STRING_TYPE)), std::vector{}), + std::make_tuple(4, "status", false, std::make_unique>("meta.JobStatus"), std::vector{}), + std::make_tuple(5, "start_time", false, std::make_unique(ThriftPrimitiveType::THRIFT_I64_TYPE), std::vector{}), + std::make_tuple(6, "stop_time", false, std::make_unique(ThriftPrimitiveType::THRIFT_I64_TYPE), std::vector{}), + }; + for (const auto& f : meta_JobDesc_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_JobDesc.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::TaskDesc>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.TaskDesc", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_TaskDesc = res.first->second; + meta_TaskDesc.name_ref() = "meta.TaskDesc"; + meta_TaskDesc.is_union_ref() = false; + static const EncodedThriftField + meta_TaskDesc_fields[] = { + std::make_tuple(1, "task_id", false, std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE), std::vector{}), + std::make_tuple(2, "host", false, std::make_unique>("common.HostAddr"), std::vector{}), + std::make_tuple(3, "status", false, std::make_unique>("meta.JobStatus"), std::vector{}), + std::make_tuple(4, "start_time", false, std::make_unique(ThriftPrimitiveType::THRIFT_I64_TYPE), std::vector{}), + std::make_tuple(5, "stop_time", false, std::make_unique(ThriftPrimitiveType::THRIFT_I64_TYPE), std::vector{}), + std::make_tuple(6, "job_id", false, std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE), std::vector{}), + }; + for (const auto& f : meta_TaskDesc_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_TaskDesc.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::AdminJobResult>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.AdminJobResult", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_AdminJobResult = res.first->second; + meta_AdminJobResult.name_ref() = "meta.AdminJobResult"; + meta_AdminJobResult.is_union_ref() = false; + static const EncodedThriftField + meta_AdminJobResult_fields[] = { + std::make_tuple(1, "job_id", true, std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE), std::vector{}), + std::make_tuple(2, "job_desc", true, std::make_unique(std::make_unique>("meta.JobDesc")), std::vector{}), + std::make_tuple(3, "task_desc", true, std::make_unique(std::make_unique>("meta.TaskDesc")), std::vector{}), + std::make_tuple(4, "recovered_job_num", true, std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE), std::vector{}), + }; + for (const auto& f : meta_AdminJobResult_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_AdminJobResult.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::AdminJobResp>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.AdminJobResp", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_AdminJobResp = res.first->second; + meta_AdminJobResp.name_ref() = "meta.AdminJobResp"; + meta_AdminJobResp.is_union_ref() = false; + static const EncodedThriftField + meta_AdminJobResp_fields[] = { + std::make_tuple(1, "code", false, std::make_unique>("common.ErrorCode"), std::vector{}), + std::make_tuple(2, "leader", false, std::make_unique>("common.HostAddr"), std::vector{}), + std::make_tuple(3, "result", false, std::make_unique>("meta.AdminJobResult"), std::vector{}), + }; + for (const auto& f : meta_AdminJobResp_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_AdminJobResp.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::Correlativity>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.Correlativity", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_Correlativity = res.first->second; + meta_Correlativity.name_ref() = "meta.Correlativity"; + meta_Correlativity.is_union_ref() = false; + static const EncodedThriftField + meta_Correlativity_fields[] = { + std::make_tuple(1, "part_id", false, std::make_unique("common.PartitionID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + std::make_tuple(2, "proportion", false, std::make_unique(ThriftPrimitiveType::THRIFT_DOUBLE_TYPE), std::vector{}), + }; + for (const auto& f : meta_Correlativity_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_Correlativity.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::StatsItem>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.StatsItem", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_StatsItem = res.first->second; + meta_StatsItem.name_ref() = "meta.StatsItem"; + meta_StatsItem.is_union_ref() = false; + static const EncodedThriftField + meta_StatsItem_fields[] = { + std::make_tuple(1, "tag_vertices", false, std::make_unique(std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::make_unique(ThriftPrimitiveType::THRIFT_I64_TYPE)), std::vector{}), + std::make_tuple(2, "edges", false, std::make_unique(std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::make_unique(ThriftPrimitiveType::THRIFT_I64_TYPE)), std::vector{}), + std::make_tuple(3, "space_vertices", false, std::make_unique(ThriftPrimitiveType::THRIFT_I64_TYPE), std::vector{}), + std::make_tuple(4, "space_edges", false, std::make_unique(ThriftPrimitiveType::THRIFT_I64_TYPE), std::vector{}), + std::make_tuple(5, "positive_part_correlativity", false, std::make_unique(std::make_unique("common.PartitionID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::make_unique(std::make_unique>("meta.Correlativity"))), std::vector{}), + std::make_tuple(6, "negative_part_correlativity", false, std::make_unique(std::make_unique("common.PartitionID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::make_unique(std::make_unique>("meta.Correlativity"))), std::vector{}), + std::make_tuple(7, "status", false, std::make_unique>("meta.JobStatus"), std::vector{}), + }; + for (const auto& f : meta_StatsItem_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_StatsItem.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::CreateSpaceReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.CreateSpaceReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_CreateSpaceReq = res.first->second; + meta_CreateSpaceReq.name_ref() = "meta.CreateSpaceReq"; + meta_CreateSpaceReq.is_union_ref() = false; + static const EncodedThriftField + meta_CreateSpaceReq_fields[] = { + std::make_tuple(1, "properties", false, std::make_unique>("meta.SpaceDesc"), std::vector{}), + std::make_tuple(2, "if_not_exists", false, std::make_unique(ThriftPrimitiveType::THRIFT_BOOL_TYPE), std::vector{}), + }; + for (const auto& f : meta_CreateSpaceReq_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_CreateSpaceReq.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::CreateSpaceAsReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.CreateSpaceAsReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_CreateSpaceAsReq = res.first->second; + meta_CreateSpaceAsReq.name_ref() = "meta.CreateSpaceAsReq"; + meta_CreateSpaceAsReq.is_union_ref() = false; + static const EncodedThriftField + meta_CreateSpaceAsReq_fields[] = { + std::make_tuple(1, "old_space_name", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + std::make_tuple(2, "new_space_name", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + }; + for (const auto& f : meta_CreateSpaceAsReq_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_CreateSpaceAsReq.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::DropSpaceReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.DropSpaceReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_DropSpaceReq = res.first->second; + meta_DropSpaceReq.name_ref() = "meta.DropSpaceReq"; + meta_DropSpaceReq.is_union_ref() = false; + static const EncodedThriftField + meta_DropSpaceReq_fields[] = { + std::make_tuple(1, "space_name", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + std::make_tuple(2, "if_exists", false, std::make_unique(ThriftPrimitiveType::THRIFT_BOOL_TYPE), std::vector{}), + }; + for (const auto& f : meta_DropSpaceReq_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_DropSpaceReq.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::ListSpacesReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.ListSpacesReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_ListSpacesReq = res.first->second; + meta_ListSpacesReq.name_ref() = "meta.ListSpacesReq"; + meta_ListSpacesReq.is_union_ref() = false; + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::ListSpacesResp>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.ListSpacesResp", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_ListSpacesResp = res.first->second; + meta_ListSpacesResp.name_ref() = "meta.ListSpacesResp"; + meta_ListSpacesResp.is_union_ref() = false; + static const EncodedThriftField + meta_ListSpacesResp_fields[] = { + std::make_tuple(1, "code", false, std::make_unique>("common.ErrorCode"), std::vector{}), + std::make_tuple(2, "leader", false, std::make_unique>("common.HostAddr"), std::vector{}), + std::make_tuple(3, "spaces", false, std::make_unique(std::make_unique>("meta.IdName")), std::vector{}), + }; + for (const auto& f : meta_ListSpacesResp_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_ListSpacesResp.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::GetSpaceReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.GetSpaceReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_GetSpaceReq = res.first->second; + meta_GetSpaceReq.name_ref() = "meta.GetSpaceReq"; + meta_GetSpaceReq.is_union_ref() = false; + static const EncodedThriftField + meta_GetSpaceReq_fields[] = { + std::make_tuple(1, "space_name", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + }; + for (const auto& f : meta_GetSpaceReq_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_GetSpaceReq.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::GetSpaceResp>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.GetSpaceResp", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_GetSpaceResp = res.first->second; + meta_GetSpaceResp.name_ref() = "meta.GetSpaceResp"; + meta_GetSpaceResp.is_union_ref() = false; + static const EncodedThriftField + meta_GetSpaceResp_fields[] = { + std::make_tuple(1, "code", false, std::make_unique>("common.ErrorCode"), std::vector{}), + std::make_tuple(2, "leader", false, std::make_unique>("common.HostAddr"), std::vector{}), + std::make_tuple(3, "item", false, std::make_unique>("meta.SpaceItem"), std::vector{}), + }; + for (const auto& f : meta_GetSpaceResp_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_GetSpaceResp.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::CreateTagReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.CreateTagReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_CreateTagReq = res.first->second; + meta_CreateTagReq.name_ref() = "meta.CreateTagReq"; + meta_CreateTagReq.is_union_ref() = false; + static const EncodedThriftField + meta_CreateTagReq_fields[] = { + std::make_tuple(1, "space_id", false, std::make_unique("common.GraphSpaceID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + std::make_tuple(2, "tag_name", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + std::make_tuple(3, "schema", false, std::make_unique>("meta.Schema"), std::vector{}), + std::make_tuple(4, "if_not_exists", false, std::make_unique(ThriftPrimitiveType::THRIFT_BOOL_TYPE), std::vector{}), + }; + for (const auto& f : meta_CreateTagReq_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_CreateTagReq.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::AlterTagReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.AlterTagReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_AlterTagReq = res.first->second; + meta_AlterTagReq.name_ref() = "meta.AlterTagReq"; + meta_AlterTagReq.is_union_ref() = false; + static const EncodedThriftField + meta_AlterTagReq_fields[] = { + std::make_tuple(1, "space_id", false, std::make_unique("common.GraphSpaceID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + std::make_tuple(2, "tag_name", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + std::make_tuple(3, "tag_items", false, std::make_unique(std::make_unique>("meta.AlterSchemaItem")), std::vector{}), + std::make_tuple(4, "schema_prop", false, std::make_unique>("meta.SchemaProp"), std::vector{}), + }; + for (const auto& f : meta_AlterTagReq_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_AlterTagReq.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::DropTagReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.DropTagReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_DropTagReq = res.first->second; + meta_DropTagReq.name_ref() = "meta.DropTagReq"; + meta_DropTagReq.is_union_ref() = false; + static const EncodedThriftField + meta_DropTagReq_fields[] = { + std::make_tuple(1, "space_id", false, std::make_unique("common.GraphSpaceID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + std::make_tuple(2, "tag_name", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + std::make_tuple(3, "if_exists", false, std::make_unique(ThriftPrimitiveType::THRIFT_BOOL_TYPE), std::vector{}), + }; + for (const auto& f : meta_DropTagReq_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_DropTagReq.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::ListTagsReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.ListTagsReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_ListTagsReq = res.first->second; + meta_ListTagsReq.name_ref() = "meta.ListTagsReq"; + meta_ListTagsReq.is_union_ref() = false; + static const EncodedThriftField + meta_ListTagsReq_fields[] = { + std::make_tuple(1, "space_id", false, std::make_unique("common.GraphSpaceID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + }; + for (const auto& f : meta_ListTagsReq_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_ListTagsReq.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::ListTagsResp>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.ListTagsResp", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_ListTagsResp = res.first->second; + meta_ListTagsResp.name_ref() = "meta.ListTagsResp"; + meta_ListTagsResp.is_union_ref() = false; + static const EncodedThriftField + meta_ListTagsResp_fields[] = { + std::make_tuple(1, "code", false, std::make_unique>("common.ErrorCode"), std::vector{}), + std::make_tuple(2, "leader", false, std::make_unique>("common.HostAddr"), std::vector{}), + std::make_tuple(3, "tags", false, std::make_unique(std::make_unique>("meta.TagItem")), std::vector{}), + }; + for (const auto& f : meta_ListTagsResp_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_ListTagsResp.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::GetTagReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.GetTagReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_GetTagReq = res.first->second; + meta_GetTagReq.name_ref() = "meta.GetTagReq"; + meta_GetTagReq.is_union_ref() = false; + static const EncodedThriftField + meta_GetTagReq_fields[] = { + std::make_tuple(1, "space_id", false, std::make_unique("common.GraphSpaceID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + std::make_tuple(2, "tag_name", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + std::make_tuple(3, "version", false, std::make_unique("meta.SchemaVer", std::make_unique(ThriftPrimitiveType::THRIFT_I64_TYPE)), std::vector{}), + }; + for (const auto& f : meta_GetTagReq_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_GetTagReq.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::GetTagResp>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.GetTagResp", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_GetTagResp = res.first->second; + meta_GetTagResp.name_ref() = "meta.GetTagResp"; + meta_GetTagResp.is_union_ref() = false; + static const EncodedThriftField + meta_GetTagResp_fields[] = { + std::make_tuple(1, "code", false, std::make_unique>("common.ErrorCode"), std::vector{}), + std::make_tuple(2, "leader", false, std::make_unique>("common.HostAddr"), std::vector{}), + std::make_tuple(3, "schema", false, std::make_unique>("meta.Schema"), std::vector{}), + }; + for (const auto& f : meta_GetTagResp_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_GetTagResp.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::CreateEdgeReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.CreateEdgeReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_CreateEdgeReq = res.first->second; + meta_CreateEdgeReq.name_ref() = "meta.CreateEdgeReq"; + meta_CreateEdgeReq.is_union_ref() = false; + static const EncodedThriftField + meta_CreateEdgeReq_fields[] = { + std::make_tuple(1, "space_id", false, std::make_unique("common.GraphSpaceID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + std::make_tuple(2, "edge_name", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + std::make_tuple(3, "schema", false, std::make_unique>("meta.Schema"), std::vector{}), + std::make_tuple(4, "if_not_exists", false, std::make_unique(ThriftPrimitiveType::THRIFT_BOOL_TYPE), std::vector{}), + }; + for (const auto& f : meta_CreateEdgeReq_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_CreateEdgeReq.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::AlterEdgeReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.AlterEdgeReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_AlterEdgeReq = res.first->second; + meta_AlterEdgeReq.name_ref() = "meta.AlterEdgeReq"; + meta_AlterEdgeReq.is_union_ref() = false; + static const EncodedThriftField + meta_AlterEdgeReq_fields[] = { + std::make_tuple(1, "space_id", false, std::make_unique("common.GraphSpaceID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + std::make_tuple(2, "edge_name", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + std::make_tuple(3, "edge_items", false, std::make_unique(std::make_unique>("meta.AlterSchemaItem")), std::vector{}), + std::make_tuple(4, "schema_prop", false, std::make_unique>("meta.SchemaProp"), std::vector{}), + }; + for (const auto& f : meta_AlterEdgeReq_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_AlterEdgeReq.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::GetEdgeReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.GetEdgeReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_GetEdgeReq = res.first->second; + meta_GetEdgeReq.name_ref() = "meta.GetEdgeReq"; + meta_GetEdgeReq.is_union_ref() = false; + static const EncodedThriftField + meta_GetEdgeReq_fields[] = { + std::make_tuple(1, "space_id", false, std::make_unique("common.GraphSpaceID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + std::make_tuple(2, "edge_name", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + std::make_tuple(3, "version", false, std::make_unique("meta.SchemaVer", std::make_unique(ThriftPrimitiveType::THRIFT_I64_TYPE)), std::vector{}), + }; + for (const auto& f : meta_GetEdgeReq_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_GetEdgeReq.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::GetEdgeResp>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.GetEdgeResp", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_GetEdgeResp = res.first->second; + meta_GetEdgeResp.name_ref() = "meta.GetEdgeResp"; + meta_GetEdgeResp.is_union_ref() = false; + static const EncodedThriftField + meta_GetEdgeResp_fields[] = { + std::make_tuple(1, "code", false, std::make_unique>("common.ErrorCode"), std::vector{}), + std::make_tuple(2, "leader", false, std::make_unique>("common.HostAddr"), std::vector{}), + std::make_tuple(3, "schema", false, std::make_unique>("meta.Schema"), std::vector{}), + }; + for (const auto& f : meta_GetEdgeResp_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_GetEdgeResp.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::DropEdgeReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.DropEdgeReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_DropEdgeReq = res.first->second; + meta_DropEdgeReq.name_ref() = "meta.DropEdgeReq"; + meta_DropEdgeReq.is_union_ref() = false; + static const EncodedThriftField + meta_DropEdgeReq_fields[] = { + std::make_tuple(1, "space_id", false, std::make_unique("common.GraphSpaceID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + std::make_tuple(2, "edge_name", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + std::make_tuple(3, "if_exists", false, std::make_unique(ThriftPrimitiveType::THRIFT_BOOL_TYPE), std::vector{}), + }; + for (const auto& f : meta_DropEdgeReq_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_DropEdgeReq.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::ListEdgesReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.ListEdgesReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_ListEdgesReq = res.first->second; + meta_ListEdgesReq.name_ref() = "meta.ListEdgesReq"; + meta_ListEdgesReq.is_union_ref() = false; + static const EncodedThriftField + meta_ListEdgesReq_fields[] = { + std::make_tuple(1, "space_id", false, std::make_unique("common.GraphSpaceID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + }; + for (const auto& f : meta_ListEdgesReq_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_ListEdgesReq.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::ListEdgesResp>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.ListEdgesResp", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_ListEdgesResp = res.first->second; + meta_ListEdgesResp.name_ref() = "meta.ListEdgesResp"; + meta_ListEdgesResp.is_union_ref() = false; + static const EncodedThriftField + meta_ListEdgesResp_fields[] = { + std::make_tuple(1, "code", false, std::make_unique>("common.ErrorCode"), std::vector{}), + std::make_tuple(2, "leader", false, std::make_unique>("common.HostAddr"), std::vector{}), + std::make_tuple(3, "edges", false, std::make_unique(std::make_unique>("meta.EdgeItem")), std::vector{}), + }; + for (const auto& f : meta_ListEdgesResp_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_ListEdgesResp.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::ListHostsReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.ListHostsReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_ListHostsReq = res.first->second; + meta_ListHostsReq.name_ref() = "meta.ListHostsReq"; + meta_ListHostsReq.is_union_ref() = false; + static const EncodedThriftField + meta_ListHostsReq_fields[] = { + std::make_tuple(1, "type", false, std::make_unique>("meta.ListHostType"), std::vector{}), + }; + for (const auto& f : meta_ListHostsReq_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_ListHostsReq.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::ListHostsResp>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.ListHostsResp", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_ListHostsResp = res.first->second; + meta_ListHostsResp.name_ref() = "meta.ListHostsResp"; + meta_ListHostsResp.is_union_ref() = false; + static const EncodedThriftField + meta_ListHostsResp_fields[] = { + std::make_tuple(1, "code", false, std::make_unique>("common.ErrorCode"), std::vector{}), + std::make_tuple(2, "leader", false, std::make_unique>("common.HostAddr"), std::vector{}), + std::make_tuple(3, "hosts", false, std::make_unique(std::make_unique>("meta.HostItem")), std::vector{}), + }; + for (const auto& f : meta_ListHostsResp_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_ListHostsResp.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::PartItem>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.PartItem", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_PartItem = res.first->second; + meta_PartItem.name_ref() = "meta.PartItem"; + meta_PartItem.is_union_ref() = false; + static const EncodedThriftField + meta_PartItem_fields[] = { + std::make_tuple(1, "part_id", false, std::make_unique("common.PartitionID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + std::make_tuple(2, "leader", true, std::make_unique>("common.HostAddr"), std::vector{}), + std::make_tuple(3, "peers", false, std::make_unique(std::make_unique>("common.HostAddr")), std::vector{}), + std::make_tuple(4, "losts", false, std::make_unique(std::make_unique>("common.HostAddr")), std::vector{}), + }; + for (const auto& f : meta_PartItem_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_PartItem.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::ListPartsReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.ListPartsReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_ListPartsReq = res.first->second; + meta_ListPartsReq.name_ref() = "meta.ListPartsReq"; + meta_ListPartsReq.is_union_ref() = false; + static const EncodedThriftField + meta_ListPartsReq_fields[] = { + std::make_tuple(1, "space_id", false, std::make_unique("common.GraphSpaceID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + std::make_tuple(2, "part_ids", false, std::make_unique(std::make_unique("common.PartitionID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE))), std::vector{}), + }; + for (const auto& f : meta_ListPartsReq_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_ListPartsReq.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::ListPartsResp>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.ListPartsResp", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_ListPartsResp = res.first->second; + meta_ListPartsResp.name_ref() = "meta.ListPartsResp"; + meta_ListPartsResp.is_union_ref() = false; + static const EncodedThriftField + meta_ListPartsResp_fields[] = { + std::make_tuple(1, "code", false, std::make_unique>("common.ErrorCode"), std::vector{}), + std::make_tuple(2, "leader", false, std::make_unique>("common.HostAddr"), std::vector{}), + std::make_tuple(3, "parts", false, std::make_unique(std::make_unique>("meta.PartItem")), std::vector{}), + }; + for (const auto& f : meta_ListPartsResp_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_ListPartsResp.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::GetPartsAllocReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.GetPartsAllocReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_GetPartsAllocReq = res.first->second; + meta_GetPartsAllocReq.name_ref() = "meta.GetPartsAllocReq"; + meta_GetPartsAllocReq.is_union_ref() = false; + static const EncodedThriftField + meta_GetPartsAllocReq_fields[] = { + std::make_tuple(1, "space_id", false, std::make_unique("common.GraphSpaceID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + }; + for (const auto& f : meta_GetPartsAllocReq_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_GetPartsAllocReq.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::GetPartsAllocResp>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.GetPartsAllocResp", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_GetPartsAllocResp = res.first->second; + meta_GetPartsAllocResp.name_ref() = "meta.GetPartsAllocResp"; + meta_GetPartsAllocResp.is_union_ref() = false; + static const EncodedThriftField + meta_GetPartsAllocResp_fields[] = { + std::make_tuple(1, "code", false, std::make_unique>("common.ErrorCode"), std::vector{}), + std::make_tuple(2, "leader", false, std::make_unique>("common.HostAddr"), std::vector{}), + std::make_tuple(3, "parts", false, std::make_unique(std::make_unique("common.PartitionID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::make_unique(std::make_unique>("common.HostAddr"))), std::vector{}), + std::make_tuple(4, "terms", true, std::make_unique(std::make_unique("common.PartitionID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::make_unique(ThriftPrimitiveType::THRIFT_I64_TYPE)), std::vector{}), + }; + for (const auto& f : meta_GetPartsAllocResp_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_GetPartsAllocResp.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::MultiPutReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.MultiPutReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_MultiPutReq = res.first->second; + meta_MultiPutReq.name_ref() = "meta.MultiPutReq"; + meta_MultiPutReq.is_union_ref() = false; + static const EncodedThriftField + meta_MultiPutReq_fields[] = { + std::make_tuple(1, "segment", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + std::make_tuple(2, "pairs", false, std::make_unique(std::make_unique>("common.KeyValue")), std::vector{}), + }; + for (const auto& f : meta_MultiPutReq_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_MultiPutReq.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::GetReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.GetReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_GetReq = res.first->second; + meta_GetReq.name_ref() = "meta.GetReq"; + meta_GetReq.is_union_ref() = false; + static const EncodedThriftField + meta_GetReq_fields[] = { + std::make_tuple(1, "segment", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + std::make_tuple(2, "key", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + }; + for (const auto& f : meta_GetReq_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_GetReq.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::GetResp>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.GetResp", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_GetResp = res.first->second; + meta_GetResp.name_ref() = "meta.GetResp"; + meta_GetResp.is_union_ref() = false; + static const EncodedThriftField + meta_GetResp_fields[] = { + std::make_tuple(1, "code", false, std::make_unique>("common.ErrorCode"), std::vector{}), + std::make_tuple(2, "leader", false, std::make_unique>("common.HostAddr"), std::vector{}), + std::make_tuple(3, "value", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + }; + for (const auto& f : meta_GetResp_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_GetResp.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::MultiGetReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.MultiGetReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_MultiGetReq = res.first->second; + meta_MultiGetReq.name_ref() = "meta.MultiGetReq"; + meta_MultiGetReq.is_union_ref() = false; + static const EncodedThriftField + meta_MultiGetReq_fields[] = { + std::make_tuple(1, "segment", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + std::make_tuple(2, "keys", false, std::make_unique(std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE)), std::vector{}), + }; + for (const auto& f : meta_MultiGetReq_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_MultiGetReq.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::MultiGetResp>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.MultiGetResp", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_MultiGetResp = res.first->second; + meta_MultiGetResp.name_ref() = "meta.MultiGetResp"; + meta_MultiGetResp.is_union_ref() = false; + static const EncodedThriftField + meta_MultiGetResp_fields[] = { + std::make_tuple(1, "code", false, std::make_unique>("common.ErrorCode"), std::vector{}), + std::make_tuple(2, "leader", false, std::make_unique>("common.HostAddr"), std::vector{}), + std::make_tuple(3, "values", false, std::make_unique(std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE)), std::vector{}), + }; + for (const auto& f : meta_MultiGetResp_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_MultiGetResp.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::RemoveReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.RemoveReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_RemoveReq = res.first->second; + meta_RemoveReq.name_ref() = "meta.RemoveReq"; + meta_RemoveReq.is_union_ref() = false; + static const EncodedThriftField + meta_RemoveReq_fields[] = { + std::make_tuple(1, "segment", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + std::make_tuple(2, "key", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + }; + for (const auto& f : meta_RemoveReq_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_RemoveReq.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::RemoveRangeReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.RemoveRangeReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_RemoveRangeReq = res.first->second; + meta_RemoveRangeReq.name_ref() = "meta.RemoveRangeReq"; + meta_RemoveRangeReq.is_union_ref() = false; + static const EncodedThriftField + meta_RemoveRangeReq_fields[] = { + std::make_tuple(1, "segment", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + std::make_tuple(2, "start", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + std::make_tuple(3, "end", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + }; + for (const auto& f : meta_RemoveRangeReq_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_RemoveRangeReq.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::ScanReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.ScanReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_ScanReq = res.first->second; + meta_ScanReq.name_ref() = "meta.ScanReq"; + meta_ScanReq.is_union_ref() = false; + static const EncodedThriftField + meta_ScanReq_fields[] = { + std::make_tuple(1, "segment", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + std::make_tuple(2, "start", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + std::make_tuple(3, "end", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + }; + for (const auto& f : meta_ScanReq_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_ScanReq.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::ScanResp>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.ScanResp", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_ScanResp = res.first->second; + meta_ScanResp.name_ref() = "meta.ScanResp"; + meta_ScanResp.is_union_ref() = false; + static const EncodedThriftField + meta_ScanResp_fields[] = { + std::make_tuple(1, "code", false, std::make_unique>("common.ErrorCode"), std::vector{}), + std::make_tuple(2, "leader", false, std::make_unique>("common.HostAddr"), std::vector{}), + std::make_tuple(3, "values", false, std::make_unique(std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE)), std::vector{}), + }; + for (const auto& f : meta_ScanResp_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_ScanResp.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::HBResp>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.HBResp", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_HBResp = res.first->second; + meta_HBResp.name_ref() = "meta.HBResp"; + meta_HBResp.is_union_ref() = false; + static const EncodedThriftField + meta_HBResp_fields[] = { + std::make_tuple(1, "code", false, std::make_unique>("common.ErrorCode"), std::vector{}), + std::make_tuple(2, "leader", false, std::make_unique>("common.HostAddr"), std::vector{}), + std::make_tuple(3, "cluster_id", false, std::make_unique("meta.ClusterID", std::make_unique(ThriftPrimitiveType::THRIFT_I64_TYPE)), std::vector{}), + std::make_tuple(4, "last_update_time_in_ms", false, std::make_unique(ThriftPrimitiveType::THRIFT_I64_TYPE), std::vector{}), + std::make_tuple(5, "meta_version", false, std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE), std::vector{}), + }; + for (const auto& f : meta_HBResp_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_HBResp.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::LeaderInfo>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.LeaderInfo", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_LeaderInfo = res.first->second; + meta_LeaderInfo.name_ref() = "meta.LeaderInfo"; + meta_LeaderInfo.is_union_ref() = false; + static const EncodedThriftField + meta_LeaderInfo_fields[] = { + std::make_tuple(1, "part_id", false, std::make_unique("common.PartitionID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + std::make_tuple(2, "term", false, std::make_unique(ThriftPrimitiveType::THRIFT_I64_TYPE), std::vector{}), + }; + for (const auto& f : meta_LeaderInfo_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_LeaderInfo.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::HBReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.HBReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_HBReq = res.first->second; + meta_HBReq.name_ref() = "meta.HBReq"; + meta_HBReq.is_union_ref() = false; + static const EncodedThriftField + meta_HBReq_fields[] = { + std::make_tuple(1, "role", false, std::make_unique>("meta.HostRole"), std::vector{}), + std::make_tuple(2, "host", false, std::make_unique>("common.HostAddr"), std::vector{}), + std::make_tuple(3, "cluster_id", false, std::make_unique("meta.ClusterID", std::make_unique(ThriftPrimitiveType::THRIFT_I64_TYPE)), std::vector{}), + std::make_tuple(4, "leader_partIds", true, std::make_unique(std::make_unique("common.GraphSpaceID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::make_unique(std::make_unique>("meta.LeaderInfo"))), std::vector{}), + std::make_tuple(5, "git_info_sha", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + std::make_tuple(6, "version", true, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + }; + for (const auto& f : meta_HBReq_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_HBReq.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::IndexFieldDef>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.IndexFieldDef", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_IndexFieldDef = res.first->second; + meta_IndexFieldDef.name_ref() = "meta.IndexFieldDef"; + meta_IndexFieldDef.is_union_ref() = false; + static const EncodedThriftField + meta_IndexFieldDef_fields[] = { + std::make_tuple(1, "name", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + std::make_tuple(2, "type_length", true, std::make_unique(ThriftPrimitiveType::THRIFT_I16_TYPE), std::vector{}), + }; + for (const auto& f : meta_IndexFieldDef_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_IndexFieldDef.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::CreateTagIndexReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.CreateTagIndexReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_CreateTagIndexReq = res.first->second; + meta_CreateTagIndexReq.name_ref() = "meta.CreateTagIndexReq"; + meta_CreateTagIndexReq.is_union_ref() = false; + static const EncodedThriftField + meta_CreateTagIndexReq_fields[] = { + std::make_tuple(1, "space_id", false, std::make_unique("common.GraphSpaceID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + std::make_tuple(2, "index_name", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + std::make_tuple(3, "tag_name", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + std::make_tuple(4, "fields", false, std::make_unique(std::make_unique>("meta.IndexFieldDef")), std::vector{}), + std::make_tuple(5, "if_not_exists", false, std::make_unique(ThriftPrimitiveType::THRIFT_BOOL_TYPE), std::vector{}), + std::make_tuple(6, "comment", true, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + }; + for (const auto& f : meta_CreateTagIndexReq_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_CreateTagIndexReq.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::DropTagIndexReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.DropTagIndexReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_DropTagIndexReq = res.first->second; + meta_DropTagIndexReq.name_ref() = "meta.DropTagIndexReq"; + meta_DropTagIndexReq.is_union_ref() = false; + static const EncodedThriftField + meta_DropTagIndexReq_fields[] = { + std::make_tuple(1, "space_id", false, std::make_unique("common.GraphSpaceID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + std::make_tuple(2, "index_name", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + std::make_tuple(3, "if_exists", false, std::make_unique(ThriftPrimitiveType::THRIFT_BOOL_TYPE), std::vector{}), + }; + for (const auto& f : meta_DropTagIndexReq_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_DropTagIndexReq.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::GetTagIndexReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.GetTagIndexReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_GetTagIndexReq = res.first->second; + meta_GetTagIndexReq.name_ref() = "meta.GetTagIndexReq"; + meta_GetTagIndexReq.is_union_ref() = false; + static const EncodedThriftField + meta_GetTagIndexReq_fields[] = { + std::make_tuple(1, "space_id", false, std::make_unique("common.GraphSpaceID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + std::make_tuple(2, "index_name", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + }; + for (const auto& f : meta_GetTagIndexReq_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_GetTagIndexReq.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::GetTagIndexResp>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.GetTagIndexResp", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_GetTagIndexResp = res.first->second; + meta_GetTagIndexResp.name_ref() = "meta.GetTagIndexResp"; + meta_GetTagIndexResp.is_union_ref() = false; + static const EncodedThriftField + meta_GetTagIndexResp_fields[] = { + std::make_tuple(1, "code", false, std::make_unique>("common.ErrorCode"), std::vector{}), + std::make_tuple(2, "leader", false, std::make_unique>("common.HostAddr"), std::vector{}), + std::make_tuple(3, "item", false, std::make_unique>("meta.IndexItem"), std::vector{}), + }; + for (const auto& f : meta_GetTagIndexResp_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_GetTagIndexResp.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::ListTagIndexesReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.ListTagIndexesReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_ListTagIndexesReq = res.first->second; + meta_ListTagIndexesReq.name_ref() = "meta.ListTagIndexesReq"; + meta_ListTagIndexesReq.is_union_ref() = false; + static const EncodedThriftField + meta_ListTagIndexesReq_fields[] = { + std::make_tuple(1, "space_id", false, std::make_unique("common.GraphSpaceID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + }; + for (const auto& f : meta_ListTagIndexesReq_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_ListTagIndexesReq.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::ListTagIndexesResp>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.ListTagIndexesResp", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_ListTagIndexesResp = res.first->second; + meta_ListTagIndexesResp.name_ref() = "meta.ListTagIndexesResp"; + meta_ListTagIndexesResp.is_union_ref() = false; + static const EncodedThriftField + meta_ListTagIndexesResp_fields[] = { + std::make_tuple(1, "code", false, std::make_unique>("common.ErrorCode"), std::vector{}), + std::make_tuple(2, "leader", false, std::make_unique>("common.HostAddr"), std::vector{}), + std::make_tuple(3, "items", false, std::make_unique(std::make_unique>("meta.IndexItem")), std::vector{}), + }; + for (const auto& f : meta_ListTagIndexesResp_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_ListTagIndexesResp.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::CreateEdgeIndexReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.CreateEdgeIndexReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_CreateEdgeIndexReq = res.first->second; + meta_CreateEdgeIndexReq.name_ref() = "meta.CreateEdgeIndexReq"; + meta_CreateEdgeIndexReq.is_union_ref() = false; + static const EncodedThriftField + meta_CreateEdgeIndexReq_fields[] = { + std::make_tuple(1, "space_id", false, std::make_unique("common.GraphSpaceID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + std::make_tuple(2, "index_name", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + std::make_tuple(3, "edge_name", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + std::make_tuple(4, "fields", false, std::make_unique(std::make_unique>("meta.IndexFieldDef")), std::vector{}), + std::make_tuple(5, "if_not_exists", false, std::make_unique(ThriftPrimitiveType::THRIFT_BOOL_TYPE), std::vector{}), + std::make_tuple(6, "comment", true, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + }; + for (const auto& f : meta_CreateEdgeIndexReq_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_CreateEdgeIndexReq.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::DropEdgeIndexReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.DropEdgeIndexReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_DropEdgeIndexReq = res.first->second; + meta_DropEdgeIndexReq.name_ref() = "meta.DropEdgeIndexReq"; + meta_DropEdgeIndexReq.is_union_ref() = false; + static const EncodedThriftField + meta_DropEdgeIndexReq_fields[] = { + std::make_tuple(1, "space_id", false, std::make_unique("common.GraphSpaceID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + std::make_tuple(2, "index_name", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + std::make_tuple(3, "if_exists", false, std::make_unique(ThriftPrimitiveType::THRIFT_BOOL_TYPE), std::vector{}), + }; + for (const auto& f : meta_DropEdgeIndexReq_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_DropEdgeIndexReq.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::GetEdgeIndexReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.GetEdgeIndexReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_GetEdgeIndexReq = res.first->second; + meta_GetEdgeIndexReq.name_ref() = "meta.GetEdgeIndexReq"; + meta_GetEdgeIndexReq.is_union_ref() = false; + static const EncodedThriftField + meta_GetEdgeIndexReq_fields[] = { + std::make_tuple(1, "space_id", false, std::make_unique("common.GraphSpaceID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + std::make_tuple(2, "index_name", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + }; + for (const auto& f : meta_GetEdgeIndexReq_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_GetEdgeIndexReq.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::GetEdgeIndexResp>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.GetEdgeIndexResp", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_GetEdgeIndexResp = res.first->second; + meta_GetEdgeIndexResp.name_ref() = "meta.GetEdgeIndexResp"; + meta_GetEdgeIndexResp.is_union_ref() = false; + static const EncodedThriftField + meta_GetEdgeIndexResp_fields[] = { + std::make_tuple(1, "code", false, std::make_unique>("common.ErrorCode"), std::vector{}), + std::make_tuple(2, "leader", false, std::make_unique>("common.HostAddr"), std::vector{}), + std::make_tuple(3, "item", false, std::make_unique>("meta.IndexItem"), std::vector{}), + }; + for (const auto& f : meta_GetEdgeIndexResp_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_GetEdgeIndexResp.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::ListEdgeIndexesReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.ListEdgeIndexesReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_ListEdgeIndexesReq = res.first->second; + meta_ListEdgeIndexesReq.name_ref() = "meta.ListEdgeIndexesReq"; + meta_ListEdgeIndexesReq.is_union_ref() = false; + static const EncodedThriftField + meta_ListEdgeIndexesReq_fields[] = { + std::make_tuple(1, "space_id", false, std::make_unique("common.GraphSpaceID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + }; + for (const auto& f : meta_ListEdgeIndexesReq_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_ListEdgeIndexesReq.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::ListEdgeIndexesResp>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.ListEdgeIndexesResp", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_ListEdgeIndexesResp = res.first->second; + meta_ListEdgeIndexesResp.name_ref() = "meta.ListEdgeIndexesResp"; + meta_ListEdgeIndexesResp.is_union_ref() = false; + static const EncodedThriftField + meta_ListEdgeIndexesResp_fields[] = { + std::make_tuple(1, "code", false, std::make_unique>("common.ErrorCode"), std::vector{}), + std::make_tuple(2, "leader", false, std::make_unique>("common.HostAddr"), std::vector{}), + std::make_tuple(3, "items", false, std::make_unique(std::make_unique>("meta.IndexItem")), std::vector{}), + }; + for (const auto& f : meta_ListEdgeIndexesResp_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_ListEdgeIndexesResp.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::RebuildIndexReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.RebuildIndexReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_RebuildIndexReq = res.first->second; + meta_RebuildIndexReq.name_ref() = "meta.RebuildIndexReq"; + meta_RebuildIndexReq.is_union_ref() = false; + static const EncodedThriftField + meta_RebuildIndexReq_fields[] = { + std::make_tuple(1, "space_id", false, std::make_unique("common.GraphSpaceID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + std::make_tuple(2, "index_name", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + }; + for (const auto& f : meta_RebuildIndexReq_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_RebuildIndexReq.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::CreateUserReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.CreateUserReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_CreateUserReq = res.first->second; + meta_CreateUserReq.name_ref() = "meta.CreateUserReq"; + meta_CreateUserReq.is_union_ref() = false; + static const EncodedThriftField + meta_CreateUserReq_fields[] = { + std::make_tuple(1, "account", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + std::make_tuple(2, "encoded_pwd", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + std::make_tuple(3, "if_not_exists", false, std::make_unique(ThriftPrimitiveType::THRIFT_BOOL_TYPE), std::vector{}), + }; + for (const auto& f : meta_CreateUserReq_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_CreateUserReq.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::DropUserReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.DropUserReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_DropUserReq = res.first->second; + meta_DropUserReq.name_ref() = "meta.DropUserReq"; + meta_DropUserReq.is_union_ref() = false; + static const EncodedThriftField + meta_DropUserReq_fields[] = { + std::make_tuple(1, "account", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + std::make_tuple(2, "if_exists", false, std::make_unique(ThriftPrimitiveType::THRIFT_BOOL_TYPE), std::vector{}), + }; + for (const auto& f : meta_DropUserReq_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_DropUserReq.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::AlterUserReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.AlterUserReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_AlterUserReq = res.first->second; + meta_AlterUserReq.name_ref() = "meta.AlterUserReq"; + meta_AlterUserReq.is_union_ref() = false; + static const EncodedThriftField + meta_AlterUserReq_fields[] = { + std::make_tuple(1, "account", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + std::make_tuple(2, "encoded_pwd", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + }; + for (const auto& f : meta_AlterUserReq_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_AlterUserReq.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::GrantRoleReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.GrantRoleReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_GrantRoleReq = res.first->second; + meta_GrantRoleReq.name_ref() = "meta.GrantRoleReq"; + meta_GrantRoleReq.is_union_ref() = false; + static const EncodedThriftField + meta_GrantRoleReq_fields[] = { + std::make_tuple(1, "role_item", false, std::make_unique>("meta.RoleItem"), std::vector{}), + }; + for (const auto& f : meta_GrantRoleReq_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_GrantRoleReq.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::RevokeRoleReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.RevokeRoleReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_RevokeRoleReq = res.first->second; + meta_RevokeRoleReq.name_ref() = "meta.RevokeRoleReq"; + meta_RevokeRoleReq.is_union_ref() = false; + static const EncodedThriftField + meta_RevokeRoleReq_fields[] = { + std::make_tuple(1, "role_item", false, std::make_unique>("meta.RoleItem"), std::vector{}), + }; + for (const auto& f : meta_RevokeRoleReq_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_RevokeRoleReq.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::ListUsersReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.ListUsersReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_ListUsersReq = res.first->second; + meta_ListUsersReq.name_ref() = "meta.ListUsersReq"; + meta_ListUsersReq.is_union_ref() = false; + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::ListUsersResp>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.ListUsersResp", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_ListUsersResp = res.first->second; + meta_ListUsersResp.name_ref() = "meta.ListUsersResp"; + meta_ListUsersResp.is_union_ref() = false; + static const EncodedThriftField + meta_ListUsersResp_fields[] = { + std::make_tuple(1, "code", false, std::make_unique>("common.ErrorCode"), std::vector{}), + std::make_tuple(2, "leader", false, std::make_unique>("common.HostAddr"), std::vector{}), + std::make_tuple(3, "users", false, std::make_unique(std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE)), std::vector{}), + }; + for (const auto& f : meta_ListUsersResp_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_ListUsersResp.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::ListRolesReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.ListRolesReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_ListRolesReq = res.first->second; + meta_ListRolesReq.name_ref() = "meta.ListRolesReq"; + meta_ListRolesReq.is_union_ref() = false; + static const EncodedThriftField + meta_ListRolesReq_fields[] = { + std::make_tuple(1, "space_id", false, std::make_unique("common.GraphSpaceID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + }; + for (const auto& f : meta_ListRolesReq_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_ListRolesReq.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::ListRolesResp>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.ListRolesResp", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_ListRolesResp = res.first->second; + meta_ListRolesResp.name_ref() = "meta.ListRolesResp"; + meta_ListRolesResp.is_union_ref() = false; + static const EncodedThriftField + meta_ListRolesResp_fields[] = { + std::make_tuple(1, "code", false, std::make_unique>("common.ErrorCode"), std::vector{}), + std::make_tuple(2, "leader", false, std::make_unique>("common.HostAddr"), std::vector{}), + std::make_tuple(3, "roles", false, std::make_unique(std::make_unique>("meta.RoleItem")), std::vector{}), + }; + for (const auto& f : meta_ListRolesResp_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_ListRolesResp.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::GetUserRolesReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.GetUserRolesReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_GetUserRolesReq = res.first->second; + meta_GetUserRolesReq.name_ref() = "meta.GetUserRolesReq"; + meta_GetUserRolesReq.is_union_ref() = false; + static const EncodedThriftField + meta_GetUserRolesReq_fields[] = { + std::make_tuple(1, "account", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + }; + for (const auto& f : meta_GetUserRolesReq_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_GetUserRolesReq.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::ChangePasswordReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.ChangePasswordReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_ChangePasswordReq = res.first->second; + meta_ChangePasswordReq.name_ref() = "meta.ChangePasswordReq"; + meta_ChangePasswordReq.is_union_ref() = false; + static const EncodedThriftField + meta_ChangePasswordReq_fields[] = { + std::make_tuple(1, "account", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + std::make_tuple(2, "new_encoded_pwd", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + std::make_tuple(3, "old_encoded_pwd", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + }; + for (const auto& f : meta_ChangePasswordReq_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_ChangePasswordReq.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::BalanceReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.BalanceReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_BalanceReq = res.first->second; + meta_BalanceReq.name_ref() = "meta.BalanceReq"; + meta_BalanceReq.is_union_ref() = false; + static const EncodedThriftField + meta_BalanceReq_fields[] = { + std::make_tuple(1, "space_id", true, std::make_unique("common.GraphSpaceID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + std::make_tuple(2, "id", true, std::make_unique(ThriftPrimitiveType::THRIFT_I64_TYPE), std::vector{}), + std::make_tuple(3, "host_del", true, std::make_unique(std::make_unique>("common.HostAddr")), std::vector{}), + std::make_tuple(4, "stop", true, std::make_unique(ThriftPrimitiveType::THRIFT_BOOL_TYPE), std::vector{}), + std::make_tuple(5, "reset", true, std::make_unique(ThriftPrimitiveType::THRIFT_BOOL_TYPE), std::vector{}), + }; + for (const auto& f : meta_BalanceReq_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_BalanceReq.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::BalanceTask>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.BalanceTask", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_BalanceTask = res.first->second; + meta_BalanceTask.name_ref() = "meta.BalanceTask"; + meta_BalanceTask.is_union_ref() = false; + static const EncodedThriftField + meta_BalanceTask_fields[] = { + std::make_tuple(1, "id", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + std::make_tuple(2, "result", false, std::make_unique>("meta.TaskResult"), std::vector{}), + }; + for (const auto& f : meta_BalanceTask_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_BalanceTask.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::BalanceResp>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.BalanceResp", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_BalanceResp = res.first->second; + meta_BalanceResp.name_ref() = "meta.BalanceResp"; + meta_BalanceResp.is_union_ref() = false; + static const EncodedThriftField + meta_BalanceResp_fields[] = { + std::make_tuple(1, "code", false, std::make_unique>("common.ErrorCode"), std::vector{}), + std::make_tuple(2, "id", false, std::make_unique(ThriftPrimitiveType::THRIFT_I64_TYPE), std::vector{}), + std::make_tuple(3, "leader", false, std::make_unique>("common.HostAddr"), std::vector{}), + std::make_tuple(4, "tasks", false, std::make_unique(std::make_unique>("meta.BalanceTask")), std::vector{}), + }; + for (const auto& f : meta_BalanceResp_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_BalanceResp.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::LeaderBalanceReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.LeaderBalanceReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_LeaderBalanceReq = res.first->second; + meta_LeaderBalanceReq.name_ref() = "meta.LeaderBalanceReq"; + meta_LeaderBalanceReq.is_union_ref() = false; + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::ConfigItem>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.ConfigItem", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_ConfigItem = res.first->second; + meta_ConfigItem.name_ref() = "meta.ConfigItem"; + meta_ConfigItem.is_union_ref() = false; + static const EncodedThriftField + meta_ConfigItem_fields[] = { + std::make_tuple(1, "module", false, std::make_unique>("meta.ConfigModule"), std::vector{}), + std::make_tuple(2, "name", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + std::make_tuple(3, "mode", false, std::make_unique>("meta.ConfigMode"), std::vector{}), + std::make_tuple(4, "value", false, std::make_unique>("common.Value"), std::vector{}), + }; + for (const auto& f : meta_ConfigItem_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_ConfigItem.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::RegConfigReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.RegConfigReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_RegConfigReq = res.first->second; + meta_RegConfigReq.name_ref() = "meta.RegConfigReq"; + meta_RegConfigReq.is_union_ref() = false; + static const EncodedThriftField + meta_RegConfigReq_fields[] = { + std::make_tuple(1, "items", false, std::make_unique(std::make_unique>("meta.ConfigItem")), std::vector{}), + }; + for (const auto& f : meta_RegConfigReq_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_RegConfigReq.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::GetConfigReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.GetConfigReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_GetConfigReq = res.first->second; + meta_GetConfigReq.name_ref() = "meta.GetConfigReq"; + meta_GetConfigReq.is_union_ref() = false; + static const EncodedThriftField + meta_GetConfigReq_fields[] = { + std::make_tuple(1, "item", false, std::make_unique>("meta.ConfigItem"), std::vector{}), + }; + for (const auto& f : meta_GetConfigReq_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_GetConfigReq.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::GetConfigResp>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.GetConfigResp", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_GetConfigResp = res.first->second; + meta_GetConfigResp.name_ref() = "meta.GetConfigResp"; + meta_GetConfigResp.is_union_ref() = false; + static const EncodedThriftField + meta_GetConfigResp_fields[] = { + std::make_tuple(1, "code", false, std::make_unique>("common.ErrorCode"), std::vector{}), + std::make_tuple(2, "leader", false, std::make_unique>("common.HostAddr"), std::vector{}), + std::make_tuple(3, "items", false, std::make_unique(std::make_unique>("meta.ConfigItem")), std::vector{}), + }; + for (const auto& f : meta_GetConfigResp_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_GetConfigResp.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::SetConfigReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.SetConfigReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_SetConfigReq = res.first->second; + meta_SetConfigReq.name_ref() = "meta.SetConfigReq"; + meta_SetConfigReq.is_union_ref() = false; + static const EncodedThriftField + meta_SetConfigReq_fields[] = { + std::make_tuple(1, "item", false, std::make_unique>("meta.ConfigItem"), std::vector{}), + }; + for (const auto& f : meta_SetConfigReq_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_SetConfigReq.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::ListConfigsReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.ListConfigsReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_ListConfigsReq = res.first->second; + meta_ListConfigsReq.name_ref() = "meta.ListConfigsReq"; + meta_ListConfigsReq.is_union_ref() = false; + static const EncodedThriftField + meta_ListConfigsReq_fields[] = { + std::make_tuple(1, "space", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + std::make_tuple(2, "module", false, std::make_unique>("meta.ConfigModule"), std::vector{}), + }; + for (const auto& f : meta_ListConfigsReq_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_ListConfigsReq.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::ListConfigsResp>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.ListConfigsResp", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_ListConfigsResp = res.first->second; + meta_ListConfigsResp.name_ref() = "meta.ListConfigsResp"; + meta_ListConfigsResp.is_union_ref() = false; + static const EncodedThriftField + meta_ListConfigsResp_fields[] = { + std::make_tuple(1, "code", false, std::make_unique>("common.ErrorCode"), std::vector{}), + std::make_tuple(2, "leader", false, std::make_unique>("common.HostAddr"), std::vector{}), + std::make_tuple(3, "items", false, std::make_unique(std::make_unique>("meta.ConfigItem")), std::vector{}), + }; + for (const auto& f : meta_ListConfigsResp_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_ListConfigsResp.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::CreateSnapshotReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.CreateSnapshotReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_CreateSnapshotReq = res.first->second; + meta_CreateSnapshotReq.name_ref() = "meta.CreateSnapshotReq"; + meta_CreateSnapshotReq.is_union_ref() = false; + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::DropSnapshotReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.DropSnapshotReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_DropSnapshotReq = res.first->second; + meta_DropSnapshotReq.name_ref() = "meta.DropSnapshotReq"; + meta_DropSnapshotReq.is_union_ref() = false; + static const EncodedThriftField + meta_DropSnapshotReq_fields[] = { + std::make_tuple(1, "name", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + }; + for (const auto& f : meta_DropSnapshotReq_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_DropSnapshotReq.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::ListSnapshotsReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.ListSnapshotsReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_ListSnapshotsReq = res.first->second; + meta_ListSnapshotsReq.name_ref() = "meta.ListSnapshotsReq"; + meta_ListSnapshotsReq.is_union_ref() = false; + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::Snapshot>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.Snapshot", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_Snapshot = res.first->second; + meta_Snapshot.name_ref() = "meta.Snapshot"; + meta_Snapshot.is_union_ref() = false; + static const EncodedThriftField + meta_Snapshot_fields[] = { + std::make_tuple(1, "name", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + std::make_tuple(2, "status", false, std::make_unique>("meta.SnapshotStatus"), std::vector{}), + std::make_tuple(3, "hosts", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + }; + for (const auto& f : meta_Snapshot_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_Snapshot.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::ListSnapshotsResp>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.ListSnapshotsResp", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_ListSnapshotsResp = res.first->second; + meta_ListSnapshotsResp.name_ref() = "meta.ListSnapshotsResp"; + meta_ListSnapshotsResp.is_union_ref() = false; + static const EncodedThriftField + meta_ListSnapshotsResp_fields[] = { + std::make_tuple(1, "code", false, std::make_unique>("common.ErrorCode"), std::vector{}), + std::make_tuple(2, "leader", false, std::make_unique>("common.HostAddr"), std::vector{}), + std::make_tuple(3, "snapshots", false, std::make_unique(std::make_unique>("meta.Snapshot")), std::vector{}), + }; + for (const auto& f : meta_ListSnapshotsResp_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_ListSnapshotsResp.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::ListIndexStatusReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.ListIndexStatusReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_ListIndexStatusReq = res.first->second; + meta_ListIndexStatusReq.name_ref() = "meta.ListIndexStatusReq"; + meta_ListIndexStatusReq.is_union_ref() = false; + static const EncodedThriftField + meta_ListIndexStatusReq_fields[] = { + std::make_tuple(1, "space_id", false, std::make_unique("common.GraphSpaceID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + }; + for (const auto& f : meta_ListIndexStatusReq_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_ListIndexStatusReq.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::IndexStatus>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.IndexStatus", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_IndexStatus = res.first->second; + meta_IndexStatus.name_ref() = "meta.IndexStatus"; + meta_IndexStatus.is_union_ref() = false; + static const EncodedThriftField + meta_IndexStatus_fields[] = { + std::make_tuple(1, "name", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + std::make_tuple(2, "status", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + }; + for (const auto& f : meta_IndexStatus_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_IndexStatus.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::ListIndexStatusResp>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.ListIndexStatusResp", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_ListIndexStatusResp = res.first->second; + meta_ListIndexStatusResp.name_ref() = "meta.ListIndexStatusResp"; + meta_ListIndexStatusResp.is_union_ref() = false; + static const EncodedThriftField + meta_ListIndexStatusResp_fields[] = { + std::make_tuple(1, "code", false, std::make_unique>("common.ErrorCode"), std::vector{}), + std::make_tuple(2, "leader", false, std::make_unique>("common.HostAddr"), std::vector{}), + std::make_tuple(3, "statuses", false, std::make_unique(std::make_unique>("meta.IndexStatus")), std::vector{}), + }; + for (const auto& f : meta_ListIndexStatusResp_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_ListIndexStatusResp.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::AddZoneReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.AddZoneReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_AddZoneReq = res.first->second; + meta_AddZoneReq.name_ref() = "meta.AddZoneReq"; + meta_AddZoneReq.is_union_ref() = false; + static const EncodedThriftField + meta_AddZoneReq_fields[] = { + std::make_tuple(1, "zone_name", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + std::make_tuple(2, "nodes", false, std::make_unique(std::make_unique>("common.HostAddr")), std::vector{}), + }; + for (const auto& f : meta_AddZoneReq_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_AddZoneReq.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::DropZoneReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.DropZoneReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_DropZoneReq = res.first->second; + meta_DropZoneReq.name_ref() = "meta.DropZoneReq"; + meta_DropZoneReq.is_union_ref() = false; + static const EncodedThriftField + meta_DropZoneReq_fields[] = { + std::make_tuple(1, "zone_name", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + }; + for (const auto& f : meta_DropZoneReq_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_DropZoneReq.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::AddHostIntoZoneReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.AddHostIntoZoneReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_AddHostIntoZoneReq = res.first->second; + meta_AddHostIntoZoneReq.name_ref() = "meta.AddHostIntoZoneReq"; + meta_AddHostIntoZoneReq.is_union_ref() = false; + static const EncodedThriftField + meta_AddHostIntoZoneReq_fields[] = { + std::make_tuple(1, "node", false, std::make_unique>("common.HostAddr"), std::vector{}), + std::make_tuple(2, "zone_name", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + }; + for (const auto& f : meta_AddHostIntoZoneReq_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_AddHostIntoZoneReq.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::DropHostFromZoneReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.DropHostFromZoneReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_DropHostFromZoneReq = res.first->second; + meta_DropHostFromZoneReq.name_ref() = "meta.DropHostFromZoneReq"; + meta_DropHostFromZoneReq.is_union_ref() = false; + static const EncodedThriftField + meta_DropHostFromZoneReq_fields[] = { + std::make_tuple(1, "node", false, std::make_unique>("common.HostAddr"), std::vector{}), + std::make_tuple(2, "zone_name", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + }; + for (const auto& f : meta_DropHostFromZoneReq_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_DropHostFromZoneReq.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::GetZoneReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.GetZoneReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_GetZoneReq = res.first->second; + meta_GetZoneReq.name_ref() = "meta.GetZoneReq"; + meta_GetZoneReq.is_union_ref() = false; + static const EncodedThriftField + meta_GetZoneReq_fields[] = { + std::make_tuple(1, "zone_name", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + }; + for (const auto& f : meta_GetZoneReq_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_GetZoneReq.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::GetZoneResp>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.GetZoneResp", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_GetZoneResp = res.first->second; + meta_GetZoneResp.name_ref() = "meta.GetZoneResp"; + meta_GetZoneResp.is_union_ref() = false; + static const EncodedThriftField + meta_GetZoneResp_fields[] = { + std::make_tuple(1, "code", false, std::make_unique>("common.ErrorCode"), std::vector{}), + std::make_tuple(2, "leader", false, std::make_unique>("common.HostAddr"), std::vector{}), + std::make_tuple(3, "hosts", false, std::make_unique(std::make_unique>("common.HostAddr")), std::vector{}), + }; + for (const auto& f : meta_GetZoneResp_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_GetZoneResp.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::ListZonesReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.ListZonesReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_ListZonesReq = res.first->second; + meta_ListZonesReq.name_ref() = "meta.ListZonesReq"; + meta_ListZonesReq.is_union_ref() = false; + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::Zone>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.Zone", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_Zone = res.first->second; + meta_Zone.name_ref() = "meta.Zone"; + meta_Zone.is_union_ref() = false; + static const EncodedThriftField + meta_Zone_fields[] = { + std::make_tuple(1, "zone_name", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + std::make_tuple(2, "nodes", false, std::make_unique(std::make_unique>("common.HostAddr")), std::vector{}), + }; + for (const auto& f : meta_Zone_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_Zone.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::ListZonesResp>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.ListZonesResp", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_ListZonesResp = res.first->second; + meta_ListZonesResp.name_ref() = "meta.ListZonesResp"; + meta_ListZonesResp.is_union_ref() = false; + static const EncodedThriftField + meta_ListZonesResp_fields[] = { + std::make_tuple(1, "code", false, std::make_unique>("common.ErrorCode"), std::vector{}), + std::make_tuple(2, "leader", false, std::make_unique>("common.HostAddr"), std::vector{}), + std::make_tuple(3, "zones", false, std::make_unique(std::make_unique>("meta.Zone")), std::vector{}), + }; + for (const auto& f : meta_ListZonesResp_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_ListZonesResp.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::AddGroupReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.AddGroupReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_AddGroupReq = res.first->second; + meta_AddGroupReq.name_ref() = "meta.AddGroupReq"; + meta_AddGroupReq.is_union_ref() = false; + static const EncodedThriftField + meta_AddGroupReq_fields[] = { + std::make_tuple(1, "group_name", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + std::make_tuple(2, "zone_names", false, std::make_unique(std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE)), std::vector{}), + }; + for (const auto& f : meta_AddGroupReq_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_AddGroupReq.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::DropGroupReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.DropGroupReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_DropGroupReq = res.first->second; + meta_DropGroupReq.name_ref() = "meta.DropGroupReq"; + meta_DropGroupReq.is_union_ref() = false; + static const EncodedThriftField + meta_DropGroupReq_fields[] = { + std::make_tuple(1, "group_name", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + }; + for (const auto& f : meta_DropGroupReq_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_DropGroupReq.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::AddZoneIntoGroupReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.AddZoneIntoGroupReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_AddZoneIntoGroupReq = res.first->second; + meta_AddZoneIntoGroupReq.name_ref() = "meta.AddZoneIntoGroupReq"; + meta_AddZoneIntoGroupReq.is_union_ref() = false; + static const EncodedThriftField + meta_AddZoneIntoGroupReq_fields[] = { + std::make_tuple(1, "zone_name", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + std::make_tuple(2, "group_name", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + }; + for (const auto& f : meta_AddZoneIntoGroupReq_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_AddZoneIntoGroupReq.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::DropZoneFromGroupReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.DropZoneFromGroupReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_DropZoneFromGroupReq = res.first->second; + meta_DropZoneFromGroupReq.name_ref() = "meta.DropZoneFromGroupReq"; + meta_DropZoneFromGroupReq.is_union_ref() = false; + static const EncodedThriftField + meta_DropZoneFromGroupReq_fields[] = { + std::make_tuple(1, "zone_name", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + std::make_tuple(2, "group_name", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + }; + for (const auto& f : meta_DropZoneFromGroupReq_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_DropZoneFromGroupReq.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::GetGroupReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.GetGroupReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_GetGroupReq = res.first->second; + meta_GetGroupReq.name_ref() = "meta.GetGroupReq"; + meta_GetGroupReq.is_union_ref() = false; + static const EncodedThriftField + meta_GetGroupReq_fields[] = { + std::make_tuple(1, "group_name", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + }; + for (const auto& f : meta_GetGroupReq_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_GetGroupReq.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::GetGroupResp>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.GetGroupResp", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_GetGroupResp = res.first->second; + meta_GetGroupResp.name_ref() = "meta.GetGroupResp"; + meta_GetGroupResp.is_union_ref() = false; + static const EncodedThriftField + meta_GetGroupResp_fields[] = { + std::make_tuple(1, "code", false, std::make_unique>("common.ErrorCode"), std::vector{}), + std::make_tuple(2, "leader", false, std::make_unique>("common.HostAddr"), std::vector{}), + std::make_tuple(3, "zone_names", false, std::make_unique(std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE)), std::vector{}), + }; + for (const auto& f : meta_GetGroupResp_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_GetGroupResp.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::ListGroupsReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.ListGroupsReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_ListGroupsReq = res.first->second; + meta_ListGroupsReq.name_ref() = "meta.ListGroupsReq"; + meta_ListGroupsReq.is_union_ref() = false; + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::Group>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.Group", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_Group = res.first->second; + meta_Group.name_ref() = "meta.Group"; + meta_Group.is_union_ref() = false; + static const EncodedThriftField + meta_Group_fields[] = { + std::make_tuple(1, "group_name", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + std::make_tuple(2, "zone_names", false, std::make_unique(std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE)), std::vector{}), + }; + for (const auto& f : meta_Group_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_Group.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::ListGroupsResp>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.ListGroupsResp", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_ListGroupsResp = res.first->second; + meta_ListGroupsResp.name_ref() = "meta.ListGroupsResp"; + meta_ListGroupsResp.is_union_ref() = false; + static const EncodedThriftField + meta_ListGroupsResp_fields[] = { + std::make_tuple(1, "code", false, std::make_unique>("common.ErrorCode"), std::vector{}), + std::make_tuple(2, "leader", false, std::make_unique>("common.HostAddr"), std::vector{}), + std::make_tuple(3, "groups", false, std::make_unique(std::make_unique>("meta.Group")), std::vector{}), + }; + for (const auto& f : meta_ListGroupsResp_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_ListGroupsResp.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::AddListenerReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.AddListenerReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_AddListenerReq = res.first->second; + meta_AddListenerReq.name_ref() = "meta.AddListenerReq"; + meta_AddListenerReq.is_union_ref() = false; + static const EncodedThriftField + meta_AddListenerReq_fields[] = { + std::make_tuple(1, "space_id", false, std::make_unique("common.GraphSpaceID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + std::make_tuple(2, "type", false, std::make_unique>("meta.ListenerType"), std::vector{}), + std::make_tuple(3, "hosts", false, std::make_unique(std::make_unique>("common.HostAddr")), std::vector{}), + }; + for (const auto& f : meta_AddListenerReq_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_AddListenerReq.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::RemoveListenerReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.RemoveListenerReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_RemoveListenerReq = res.first->second; + meta_RemoveListenerReq.name_ref() = "meta.RemoveListenerReq"; + meta_RemoveListenerReq.is_union_ref() = false; + static const EncodedThriftField + meta_RemoveListenerReq_fields[] = { + std::make_tuple(1, "space_id", false, std::make_unique("common.GraphSpaceID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + std::make_tuple(2, "type", false, std::make_unique>("meta.ListenerType"), std::vector{}), + }; + for (const auto& f : meta_RemoveListenerReq_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_RemoveListenerReq.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::ListListenerReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.ListListenerReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_ListListenerReq = res.first->second; + meta_ListListenerReq.name_ref() = "meta.ListListenerReq"; + meta_ListListenerReq.is_union_ref() = false; + static const EncodedThriftField + meta_ListListenerReq_fields[] = { + std::make_tuple(1, "space_id", false, std::make_unique("common.GraphSpaceID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + }; + for (const auto& f : meta_ListListenerReq_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_ListListenerReq.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::ListenerInfo>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.ListenerInfo", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_ListenerInfo = res.first->second; + meta_ListenerInfo.name_ref() = "meta.ListenerInfo"; + meta_ListenerInfo.is_union_ref() = false; + static const EncodedThriftField + meta_ListenerInfo_fields[] = { + std::make_tuple(1, "type", false, std::make_unique>("meta.ListenerType"), std::vector{}), + std::make_tuple(2, "host", false, std::make_unique>("common.HostAddr"), std::vector{}), + std::make_tuple(3, "part_id", false, std::make_unique("common.PartitionID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + std::make_tuple(4, "status", false, std::make_unique>("meta.HostStatus"), std::vector{}), + }; + for (const auto& f : meta_ListenerInfo_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_ListenerInfo.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::ListListenerResp>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.ListListenerResp", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_ListListenerResp = res.first->second; + meta_ListListenerResp.name_ref() = "meta.ListListenerResp"; + meta_ListListenerResp.is_union_ref() = false; + static const EncodedThriftField + meta_ListListenerResp_fields[] = { + std::make_tuple(1, "code", false, std::make_unique>("common.ErrorCode"), std::vector{}), + std::make_tuple(2, "leader", false, std::make_unique>("common.HostAddr"), std::vector{}), + std::make_tuple(3, "listeners", false, std::make_unique(std::make_unique>("meta.ListenerInfo")), std::vector{}), + }; + for (const auto& f : meta_ListListenerResp_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_ListListenerResp.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::GetStatsReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.GetStatsReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_GetStatsReq = res.first->second; + meta_GetStatsReq.name_ref() = "meta.GetStatsReq"; + meta_GetStatsReq.is_union_ref() = false; + static const EncodedThriftField + meta_GetStatsReq_fields[] = { + std::make_tuple(1, "space_id", false, std::make_unique("common.GraphSpaceID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + }; + for (const auto& f : meta_GetStatsReq_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_GetStatsReq.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::GetStatsResp>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.GetStatsResp", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_GetStatsResp = res.first->second; + meta_GetStatsResp.name_ref() = "meta.GetStatsResp"; + meta_GetStatsResp.is_union_ref() = false; + static const EncodedThriftField + meta_GetStatsResp_fields[] = { + std::make_tuple(1, "code", false, std::make_unique>("common.ErrorCode"), std::vector{}), + std::make_tuple(2, "leader", false, std::make_unique>("common.HostAddr"), std::vector{}), + std::make_tuple(3, "stats", false, std::make_unique>("meta.StatsItem"), std::vector{}), + }; + for (const auto& f : meta_GetStatsResp_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_GetStatsResp.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::BackupInfo>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.BackupInfo", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_BackupInfo = res.first->second; + meta_BackupInfo.name_ref() = "meta.BackupInfo"; + meta_BackupInfo.is_union_ref() = false; + static const EncodedThriftField + meta_BackupInfo_fields[] = { + std::make_tuple(1, "host", false, std::make_unique>("common.HostAddr"), std::vector{}), + std::make_tuple(2, "info", false, std::make_unique(std::make_unique>("common.CheckpointInfo")), std::vector{}), + }; + for (const auto& f : meta_BackupInfo_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_BackupInfo.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::SpaceBackupInfo>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.SpaceBackupInfo", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_SpaceBackupInfo = res.first->second; + meta_SpaceBackupInfo.name_ref() = "meta.SpaceBackupInfo"; + meta_SpaceBackupInfo.is_union_ref() = false; + static const EncodedThriftField + meta_SpaceBackupInfo_fields[] = { + std::make_tuple(1, "space", false, std::make_unique>("meta.SpaceDesc"), std::vector{}), + std::make_tuple(2, "info", false, std::make_unique(std::make_unique>("meta.BackupInfo")), std::vector{}), + }; + for (const auto& f : meta_SpaceBackupInfo_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_SpaceBackupInfo.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::BackupMeta>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.BackupMeta", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_BackupMeta = res.first->second; + meta_BackupMeta.name_ref() = "meta.BackupMeta"; + meta_BackupMeta.is_union_ref() = false; + static const EncodedThriftField + meta_BackupMeta_fields[] = { + std::make_tuple(1, "backup_info", false, std::make_unique(std::make_unique("common.GraphSpaceID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::make_unique>("meta.SpaceBackupInfo")), std::vector{}), + std::make_tuple(2, "meta_files", false, std::make_unique(std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE)), std::vector{}), + std::make_tuple(3, "backup_name", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + std::make_tuple(4, "full", false, std::make_unique(ThriftPrimitiveType::THRIFT_BOOL_TYPE), std::vector{}), + std::make_tuple(5, "include_system_space", false, std::make_unique(ThriftPrimitiveType::THRIFT_BOOL_TYPE), std::vector{}), + std::make_tuple(6, "create_time", false, std::make_unique(ThriftPrimitiveType::THRIFT_I64_TYPE), std::vector{}), + }; + for (const auto& f : meta_BackupMeta_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_BackupMeta.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::CreateBackupReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.CreateBackupReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_CreateBackupReq = res.first->second; + meta_CreateBackupReq.name_ref() = "meta.CreateBackupReq"; + meta_CreateBackupReq.is_union_ref() = false; + static const EncodedThriftField + meta_CreateBackupReq_fields[] = { + std::make_tuple(1, "spaces", true, std::make_unique(std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE)), std::vector{}), + }; + for (const auto& f : meta_CreateBackupReq_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_CreateBackupReq.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::CreateBackupResp>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.CreateBackupResp", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_CreateBackupResp = res.first->second; + meta_CreateBackupResp.name_ref() = "meta.CreateBackupResp"; + meta_CreateBackupResp.is_union_ref() = false; + static const EncodedThriftField + meta_CreateBackupResp_fields[] = { + std::make_tuple(1, "code", false, std::make_unique>("common.ErrorCode"), std::vector{}), + std::make_tuple(2, "leader", false, std::make_unique>("common.HostAddr"), std::vector{}), + std::make_tuple(3, "meta", false, std::make_unique>("meta.BackupMeta"), std::vector{}), + }; + for (const auto& f : meta_CreateBackupResp_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_CreateBackupResp.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::HostPair>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.HostPair", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_HostPair = res.first->second; + meta_HostPair.name_ref() = "meta.HostPair"; + meta_HostPair.is_union_ref() = false; + static const EncodedThriftField + meta_HostPair_fields[] = { + std::make_tuple(1, "from_host", false, std::make_unique>("common.HostAddr"), std::vector{}), + std::make_tuple(2, "to_host", false, std::make_unique>("common.HostAddr"), std::vector{}), + }; + for (const auto& f : meta_HostPair_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_HostPair.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::RestoreMetaReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.RestoreMetaReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_RestoreMetaReq = res.first->second; + meta_RestoreMetaReq.name_ref() = "meta.RestoreMetaReq"; + meta_RestoreMetaReq.is_union_ref() = false; + static const EncodedThriftField + meta_RestoreMetaReq_fields[] = { + std::make_tuple(1, "files", false, std::make_unique(std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE)), std::vector{}), + std::make_tuple(2, "hosts", false, std::make_unique(std::make_unique>("meta.HostPair")), std::vector{}), + }; + for (const auto& f : meta_RestoreMetaReq_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_RestoreMetaReq.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::FTClient>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.FTClient", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_FTClient = res.first->second; + meta_FTClient.name_ref() = "meta.FTClient"; + meta_FTClient.is_union_ref() = false; + static const EncodedThriftField + meta_FTClient_fields[] = { + std::make_tuple(1, "host", false, std::make_unique>("common.HostAddr"), std::vector{}), + std::make_tuple(2, "user", true, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + std::make_tuple(3, "pwd", true, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + }; + for (const auto& f : meta_FTClient_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_FTClient.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::SignInFTServiceReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.SignInFTServiceReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_SignInFTServiceReq = res.first->second; + meta_SignInFTServiceReq.name_ref() = "meta.SignInFTServiceReq"; + meta_SignInFTServiceReq.is_union_ref() = false; + static const EncodedThriftField + meta_SignInFTServiceReq_fields[] = { + std::make_tuple(1, "type", false, std::make_unique>("meta.FTServiceType"), std::vector{}), + std::make_tuple(2, "clients", false, std::make_unique(std::make_unique>("meta.FTClient")), std::vector{}), + }; + for (const auto& f : meta_SignInFTServiceReq_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_SignInFTServiceReq.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::SignOutFTServiceReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.SignOutFTServiceReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_SignOutFTServiceReq = res.first->second; + meta_SignOutFTServiceReq.name_ref() = "meta.SignOutFTServiceReq"; + meta_SignOutFTServiceReq.is_union_ref() = false; + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::ListFTClientsReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.ListFTClientsReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_ListFTClientsReq = res.first->second; + meta_ListFTClientsReq.name_ref() = "meta.ListFTClientsReq"; + meta_ListFTClientsReq.is_union_ref() = false; + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::ListFTClientsResp>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.ListFTClientsResp", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_ListFTClientsResp = res.first->second; + meta_ListFTClientsResp.name_ref() = "meta.ListFTClientsResp"; + meta_ListFTClientsResp.is_union_ref() = false; + static const EncodedThriftField + meta_ListFTClientsResp_fields[] = { + std::make_tuple(1, "code", false, std::make_unique>("common.ErrorCode"), std::vector{}), + std::make_tuple(2, "leader", false, std::make_unique>("common.HostAddr"), std::vector{}), + std::make_tuple(3, "clients", false, std::make_unique(std::make_unique>("meta.FTClient")), std::vector{}), + }; + for (const auto& f : meta_ListFTClientsResp_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_ListFTClientsResp.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::FTIndex>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.FTIndex", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_FTIndex = res.first->second; + meta_FTIndex.name_ref() = "meta.FTIndex"; + meta_FTIndex.is_union_ref() = false; + static const EncodedThriftField + meta_FTIndex_fields[] = { + std::make_tuple(1, "space_id", false, std::make_unique("common.GraphSpaceID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + std::make_tuple(2, "depend_schema", false, std::make_unique>("common.SchemaID"), std::vector{}), + std::make_tuple(3, "fields", false, std::make_unique(std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE)), std::vector{}), + }; + for (const auto& f : meta_FTIndex_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_FTIndex.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::CreateFTIndexReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.CreateFTIndexReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_CreateFTIndexReq = res.first->second; + meta_CreateFTIndexReq.name_ref() = "meta.CreateFTIndexReq"; + meta_CreateFTIndexReq.is_union_ref() = false; + static const EncodedThriftField + meta_CreateFTIndexReq_fields[] = { + std::make_tuple(1, "fulltext_index_name", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + std::make_tuple(2, "index", false, std::make_unique>("meta.FTIndex"), std::vector{}), + }; + for (const auto& f : meta_CreateFTIndexReq_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_CreateFTIndexReq.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::DropFTIndexReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.DropFTIndexReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_DropFTIndexReq = res.first->second; + meta_DropFTIndexReq.name_ref() = "meta.DropFTIndexReq"; + meta_DropFTIndexReq.is_union_ref() = false; + static const EncodedThriftField + meta_DropFTIndexReq_fields[] = { + std::make_tuple(1, "space_id", false, std::make_unique("common.GraphSpaceID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + std::make_tuple(2, "fulltext_index_name", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + }; + for (const auto& f : meta_DropFTIndexReq_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_DropFTIndexReq.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::ListFTIndexesReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.ListFTIndexesReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_ListFTIndexesReq = res.first->second; + meta_ListFTIndexesReq.name_ref() = "meta.ListFTIndexesReq"; + meta_ListFTIndexesReq.is_union_ref() = false; + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::ListFTIndexesResp>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.ListFTIndexesResp", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_ListFTIndexesResp = res.first->second; + meta_ListFTIndexesResp.name_ref() = "meta.ListFTIndexesResp"; + meta_ListFTIndexesResp.is_union_ref() = false; + static const EncodedThriftField + meta_ListFTIndexesResp_fields[] = { + std::make_tuple(1, "code", false, std::make_unique>("common.ErrorCode"), std::vector{}), + std::make_tuple(2, "leader", false, std::make_unique>("common.HostAddr"), std::vector{}), + std::make_tuple(3, "indexes", false, std::make_unique(std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::make_unique>("meta.FTIndex")), std::vector{}), + }; + for (const auto& f : meta_ListFTIndexesResp_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_ListFTIndexesResp.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::QueryDesc>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.QueryDesc", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_QueryDesc = res.first->second; + meta_QueryDesc.name_ref() = "meta.QueryDesc"; + meta_QueryDesc.is_union_ref() = false; + static const EncodedThriftField + meta_QueryDesc_fields[] = { + std::make_tuple(1, "start_time", false, std::make_unique("common.Timestamp", std::make_unique(ThriftPrimitiveType::THRIFT_I64_TYPE)), std::vector{}), + std::make_tuple(2, "status", false, std::make_unique>("meta.QueryStatus"), std::vector{}), + std::make_tuple(3, "duration", false, std::make_unique(ThriftPrimitiveType::THRIFT_I64_TYPE), std::vector{}), + std::make_tuple(4, "query", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + std::make_tuple(5, "graph_addr", false, std::make_unique>("common.HostAddr"), std::vector{}), + }; + for (const auto& f : meta_QueryDesc_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_QueryDesc.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::Session>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.Session", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_Session = res.first->second; + meta_Session.name_ref() = "meta.Session"; + meta_Session.is_union_ref() = false; + static const EncodedThriftField + meta_Session_fields[] = { + std::make_tuple(1, "session_id", false, std::make_unique("common.SessionID", std::make_unique(ThriftPrimitiveType::THRIFT_I64_TYPE)), std::vector{}), + std::make_tuple(2, "create_time", false, std::make_unique("common.Timestamp", std::make_unique(ThriftPrimitiveType::THRIFT_I64_TYPE)), std::vector{}), + std::make_tuple(3, "update_time", false, std::make_unique("common.Timestamp", std::make_unique(ThriftPrimitiveType::THRIFT_I64_TYPE)), std::vector{}), + std::make_tuple(4, "user_name", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + std::make_tuple(5, "space_name", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + std::make_tuple(6, "graph_addr", false, std::make_unique>("common.HostAddr"), std::vector{}), + std::make_tuple(7, "timezone", false, std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE), std::vector{}), + std::make_tuple(8, "client_ip", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + std::make_tuple(9, "configs", false, std::make_unique(std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::make_unique>("common.Value")), std::vector{}), + std::make_tuple(10, "queries", false, std::make_unique(std::make_unique("common.ExecutionPlanID", std::make_unique(ThriftPrimitiveType::THRIFT_I64_TYPE)), std::make_unique>("meta.QueryDesc")), std::vector{}), + }; + for (const auto& f : meta_Session_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_Session.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::CreateSessionReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.CreateSessionReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_CreateSessionReq = res.first->second; + meta_CreateSessionReq.name_ref() = "meta.CreateSessionReq"; + meta_CreateSessionReq.is_union_ref() = false; + static const EncodedThriftField + meta_CreateSessionReq_fields[] = { + std::make_tuple(1, "user", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + std::make_tuple(2, "graph_addr", false, std::make_unique>("common.HostAddr"), std::vector{}), + std::make_tuple(3, "client_ip", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + }; + for (const auto& f : meta_CreateSessionReq_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_CreateSessionReq.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::CreateSessionResp>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.CreateSessionResp", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_CreateSessionResp = res.first->second; + meta_CreateSessionResp.name_ref() = "meta.CreateSessionResp"; + meta_CreateSessionResp.is_union_ref() = false; + static const EncodedThriftField + meta_CreateSessionResp_fields[] = { + std::make_tuple(1, "code", false, std::make_unique>("common.ErrorCode"), std::vector{}), + std::make_tuple(2, "leader", false, std::make_unique>("common.HostAddr"), std::vector{}), + std::make_tuple(3, "session", false, std::make_unique>("meta.Session"), std::vector{}), + }; + for (const auto& f : meta_CreateSessionResp_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_CreateSessionResp.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::UpdateSessionsReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.UpdateSessionsReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_UpdateSessionsReq = res.first->second; + meta_UpdateSessionsReq.name_ref() = "meta.UpdateSessionsReq"; + meta_UpdateSessionsReq.is_union_ref() = false; + static const EncodedThriftField + meta_UpdateSessionsReq_fields[] = { + std::make_tuple(1, "sessions", false, std::make_unique(std::make_unique>("meta.Session")), std::vector{}), + }; + for (const auto& f : meta_UpdateSessionsReq_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_UpdateSessionsReq.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::UpdateSessionsResp>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.UpdateSessionsResp", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_UpdateSessionsResp = res.first->second; + meta_UpdateSessionsResp.name_ref() = "meta.UpdateSessionsResp"; + meta_UpdateSessionsResp.is_union_ref() = false; + static const EncodedThriftField + meta_UpdateSessionsResp_fields[] = { + std::make_tuple(1, "code", false, std::make_unique>("common.ErrorCode"), std::vector{}), + std::make_tuple(2, "leader", false, std::make_unique>("common.HostAddr"), std::vector{}), + std::make_tuple(3, "killed_queries", false, std::make_unique(std::make_unique("common.SessionID", std::make_unique(ThriftPrimitiveType::THRIFT_I64_TYPE)), std::make_unique(std::make_unique("common.ExecutionPlanID", std::make_unique(ThriftPrimitiveType::THRIFT_I64_TYPE)), std::make_unique>("meta.QueryDesc"))), std::vector{}), + }; + for (const auto& f : meta_UpdateSessionsResp_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_UpdateSessionsResp.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::ListSessionsReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.ListSessionsReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_ListSessionsReq = res.first->second; + meta_ListSessionsReq.name_ref() = "meta.ListSessionsReq"; + meta_ListSessionsReq.is_union_ref() = false; + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::ListSessionsResp>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.ListSessionsResp", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_ListSessionsResp = res.first->second; + meta_ListSessionsResp.name_ref() = "meta.ListSessionsResp"; + meta_ListSessionsResp.is_union_ref() = false; + static const EncodedThriftField + meta_ListSessionsResp_fields[] = { + std::make_tuple(1, "code", false, std::make_unique>("common.ErrorCode"), std::vector{}), + std::make_tuple(2, "leader", false, std::make_unique>("common.HostAddr"), std::vector{}), + std::make_tuple(3, "sessions", false, std::make_unique(std::make_unique>("meta.Session")), std::vector{}), + }; + for (const auto& f : meta_ListSessionsResp_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_ListSessionsResp.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::GetSessionReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.GetSessionReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_GetSessionReq = res.first->second; + meta_GetSessionReq.name_ref() = "meta.GetSessionReq"; + meta_GetSessionReq.is_union_ref() = false; + static const EncodedThriftField + meta_GetSessionReq_fields[] = { + std::make_tuple(1, "session_id", false, std::make_unique("common.SessionID", std::make_unique(ThriftPrimitiveType::THRIFT_I64_TYPE)), std::vector{}), + }; + for (const auto& f : meta_GetSessionReq_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_GetSessionReq.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::GetSessionResp>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.GetSessionResp", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_GetSessionResp = res.first->second; + meta_GetSessionResp.name_ref() = "meta.GetSessionResp"; + meta_GetSessionResp.is_union_ref() = false; + static const EncodedThriftField + meta_GetSessionResp_fields[] = { + std::make_tuple(1, "code", false, std::make_unique>("common.ErrorCode"), std::vector{}), + std::make_tuple(2, "leader", false, std::make_unique>("common.HostAddr"), std::vector{}), + std::make_tuple(3, "session", false, std::make_unique>("meta.Session"), std::vector{}), + }; + for (const auto& f : meta_GetSessionResp_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_GetSessionResp.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::RemoveSessionReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.RemoveSessionReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_RemoveSessionReq = res.first->second; + meta_RemoveSessionReq.name_ref() = "meta.RemoveSessionReq"; + meta_RemoveSessionReq.is_union_ref() = false; + static const EncodedThriftField + meta_RemoveSessionReq_fields[] = { + std::make_tuple(1, "session_id", false, std::make_unique("common.SessionID", std::make_unique(ThriftPrimitiveType::THRIFT_I64_TYPE)), std::vector{}), + }; + for (const auto& f : meta_RemoveSessionReq_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_RemoveSessionReq.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::KillQueryReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.KillQueryReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_KillQueryReq = res.first->second; + meta_KillQueryReq.name_ref() = "meta.KillQueryReq"; + meta_KillQueryReq.is_union_ref() = false; + static const EncodedThriftField + meta_KillQueryReq_fields[] = { + std::make_tuple(1, "kill_queries", false, std::make_unique(std::make_unique("common.SessionID", std::make_unique(ThriftPrimitiveType::THRIFT_I64_TYPE)), std::make_unique(std::make_unique("common.ExecutionPlanID", std::make_unique(ThriftPrimitiveType::THRIFT_I64_TYPE)))), std::vector{}), + }; + for (const auto& f : meta_KillQueryReq_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_KillQueryReq.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::ReportTaskReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.ReportTaskReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_ReportTaskReq = res.first->second; + meta_ReportTaskReq.name_ref() = "meta.ReportTaskReq"; + meta_ReportTaskReq.is_union_ref() = false; + static const EncodedThriftField + meta_ReportTaskReq_fields[] = { + std::make_tuple(1, "code", false, std::make_unique>("common.ErrorCode"), std::vector{}), + std::make_tuple(2, "job_id", false, std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE), std::vector{}), + std::make_tuple(3, "task_id", false, std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE), std::vector{}), + std::make_tuple(4, "stats", true, std::make_unique>("meta.StatsItem"), std::vector{}), + }; + for (const auto& f : meta_ReportTaskReq_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_ReportTaskReq.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::ListClusterInfoResp>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.ListClusterInfoResp", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_ListClusterInfoResp = res.first->second; + meta_ListClusterInfoResp.name_ref() = "meta.ListClusterInfoResp"; + meta_ListClusterInfoResp.is_union_ref() = false; + static const EncodedThriftField + meta_ListClusterInfoResp_fields[] = { + std::make_tuple(1, "code", false, std::make_unique>("common.ErrorCode"), std::vector{}), + std::make_tuple(2, "leader", false, std::make_unique>("common.HostAddr"), std::vector{}), + std::make_tuple(3, "meta_servers", false, std::make_unique(std::make_unique>("common.HostAddr")), std::vector{}), + std::make_tuple(4, "storage_servers", false, std::make_unique(std::make_unique>("common.NodeInfo")), std::vector{}), + }; + for (const auto& f : meta_ListClusterInfoResp_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_ListClusterInfoResp.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::ListClusterInfoReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.ListClusterInfoReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_ListClusterInfoReq = res.first->second; + meta_ListClusterInfoReq.name_ref() = "meta.ListClusterInfoReq"; + meta_ListClusterInfoReq.is_union_ref() = false; + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::GetMetaDirInfoResp>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.GetMetaDirInfoResp", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_GetMetaDirInfoResp = res.first->second; + meta_GetMetaDirInfoResp.name_ref() = "meta.GetMetaDirInfoResp"; + meta_GetMetaDirInfoResp.is_union_ref() = false; + static const EncodedThriftField + meta_GetMetaDirInfoResp_fields[] = { + std::make_tuple(1, "code", false, std::make_unique>("common.ErrorCode"), std::vector{}), + std::make_tuple(2, "dir", false, std::make_unique>("common.DirInfo"), std::vector{}), + }; + for (const auto& f : meta_GetMetaDirInfoResp_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_GetMetaDirInfoResp.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::GetMetaDirInfoReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.GetMetaDirInfoReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_GetMetaDirInfoReq = res.first->second; + meta_GetMetaDirInfoReq.name_ref() = "meta.GetMetaDirInfoReq"; + meta_GetMetaDirInfoReq.is_union_ref() = false; + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::VerifyClientVersionResp>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.VerifyClientVersionResp", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_VerifyClientVersionResp = res.first->second; + meta_VerifyClientVersionResp.name_ref() = "meta.VerifyClientVersionResp"; + meta_VerifyClientVersionResp.is_union_ref() = false; + static const EncodedThriftField + meta_VerifyClientVersionResp_fields[] = { + std::make_tuple(1, "code", false, std::make_unique>("common.ErrorCode"), std::vector{}), + std::make_tuple(2, "leader", false, std::make_unique>("common.HostAddr"), std::vector{}), + std::make_tuple(3, "error_msg", true, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + }; + for (const auto& f : meta_VerifyClientVersionResp_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_VerifyClientVersionResp.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::meta::cpp2::VerifyClientVersionReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("meta.VerifyClientVersionReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& meta_VerifyClientVersionReq = res.first->second; + meta_VerifyClientVersionReq.name_ref() = "meta.VerifyClientVersionReq"; + meta_VerifyClientVersionReq.is_union_ref() = false; + static const EncodedThriftField + meta_VerifyClientVersionReq_fields[] = { + std::make_tuple(1, "version", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + }; + for (const auto& f : meta_VerifyClientVersionReq_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + meta_VerifyClientVersionReq.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} + +void ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_createSpace(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "createSpace"; + auto func_ret_type = std::make_unique>("meta.ExecResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField meta_MetaService_createSpace_req_1; + meta_MetaService_createSpace_req_1.id_ref() = 1; + meta_MetaService_createSpace_req_1.name_ref() = "req"; + meta_MetaService_createSpace_req_1.is_optional_ref() = false; + auto meta_MetaService_createSpace_req_1_type = std::make_unique>("meta.CreateSpaceReq"); + meta_MetaService_createSpace_req_1_type->writeAndGenType(*meta_MetaService_createSpace_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(meta_MetaService_createSpace_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_dropSpace(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "dropSpace"; + auto func_ret_type = std::make_unique>("meta.ExecResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField meta_MetaService_dropSpace_req_1; + meta_MetaService_dropSpace_req_1.id_ref() = 1; + meta_MetaService_dropSpace_req_1.name_ref() = "req"; + meta_MetaService_dropSpace_req_1.is_optional_ref() = false; + auto meta_MetaService_dropSpace_req_1_type = std::make_unique>("meta.DropSpaceReq"); + meta_MetaService_dropSpace_req_1_type->writeAndGenType(*meta_MetaService_dropSpace_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(meta_MetaService_dropSpace_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_getSpace(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "getSpace"; + auto func_ret_type = std::make_unique>("meta.GetSpaceResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField meta_MetaService_getSpace_req_1; + meta_MetaService_getSpace_req_1.id_ref() = 1; + meta_MetaService_getSpace_req_1.name_ref() = "req"; + meta_MetaService_getSpace_req_1.is_optional_ref() = false; + auto meta_MetaService_getSpace_req_1_type = std::make_unique>("meta.GetSpaceReq"); + meta_MetaService_getSpace_req_1_type->writeAndGenType(*meta_MetaService_getSpace_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(meta_MetaService_getSpace_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_listSpaces(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "listSpaces"; + auto func_ret_type = std::make_unique>("meta.ListSpacesResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField meta_MetaService_listSpaces_req_1; + meta_MetaService_listSpaces_req_1.id_ref() = 1; + meta_MetaService_listSpaces_req_1.name_ref() = "req"; + meta_MetaService_listSpaces_req_1.is_optional_ref() = false; + auto meta_MetaService_listSpaces_req_1_type = std::make_unique>("meta.ListSpacesReq"); + meta_MetaService_listSpaces_req_1_type->writeAndGenType(*meta_MetaService_listSpaces_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(meta_MetaService_listSpaces_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_createSpaceAs(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "createSpaceAs"; + auto func_ret_type = std::make_unique>("meta.ExecResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField meta_MetaService_createSpaceAs_req_1; + meta_MetaService_createSpaceAs_req_1.id_ref() = 1; + meta_MetaService_createSpaceAs_req_1.name_ref() = "req"; + meta_MetaService_createSpaceAs_req_1.is_optional_ref() = false; + auto meta_MetaService_createSpaceAs_req_1_type = std::make_unique>("meta.CreateSpaceAsReq"); + meta_MetaService_createSpaceAs_req_1_type->writeAndGenType(*meta_MetaService_createSpaceAs_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(meta_MetaService_createSpaceAs_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_createTag(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "createTag"; + auto func_ret_type = std::make_unique>("meta.ExecResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField meta_MetaService_createTag_req_1; + meta_MetaService_createTag_req_1.id_ref() = 1; + meta_MetaService_createTag_req_1.name_ref() = "req"; + meta_MetaService_createTag_req_1.is_optional_ref() = false; + auto meta_MetaService_createTag_req_1_type = std::make_unique>("meta.CreateTagReq"); + meta_MetaService_createTag_req_1_type->writeAndGenType(*meta_MetaService_createTag_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(meta_MetaService_createTag_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_alterTag(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "alterTag"; + auto func_ret_type = std::make_unique>("meta.ExecResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField meta_MetaService_alterTag_req_1; + meta_MetaService_alterTag_req_1.id_ref() = 1; + meta_MetaService_alterTag_req_1.name_ref() = "req"; + meta_MetaService_alterTag_req_1.is_optional_ref() = false; + auto meta_MetaService_alterTag_req_1_type = std::make_unique>("meta.AlterTagReq"); + meta_MetaService_alterTag_req_1_type->writeAndGenType(*meta_MetaService_alterTag_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(meta_MetaService_alterTag_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_dropTag(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "dropTag"; + auto func_ret_type = std::make_unique>("meta.ExecResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField meta_MetaService_dropTag_req_1; + meta_MetaService_dropTag_req_1.id_ref() = 1; + meta_MetaService_dropTag_req_1.name_ref() = "req"; + meta_MetaService_dropTag_req_1.is_optional_ref() = false; + auto meta_MetaService_dropTag_req_1_type = std::make_unique>("meta.DropTagReq"); + meta_MetaService_dropTag_req_1_type->writeAndGenType(*meta_MetaService_dropTag_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(meta_MetaService_dropTag_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_getTag(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "getTag"; + auto func_ret_type = std::make_unique>("meta.GetTagResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField meta_MetaService_getTag_req_1; + meta_MetaService_getTag_req_1.id_ref() = 1; + meta_MetaService_getTag_req_1.name_ref() = "req"; + meta_MetaService_getTag_req_1.is_optional_ref() = false; + auto meta_MetaService_getTag_req_1_type = std::make_unique>("meta.GetTagReq"); + meta_MetaService_getTag_req_1_type->writeAndGenType(*meta_MetaService_getTag_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(meta_MetaService_getTag_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_listTags(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "listTags"; + auto func_ret_type = std::make_unique>("meta.ListTagsResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField meta_MetaService_listTags_req_1; + meta_MetaService_listTags_req_1.id_ref() = 1; + meta_MetaService_listTags_req_1.name_ref() = "req"; + meta_MetaService_listTags_req_1.is_optional_ref() = false; + auto meta_MetaService_listTags_req_1_type = std::make_unique>("meta.ListTagsReq"); + meta_MetaService_listTags_req_1_type->writeAndGenType(*meta_MetaService_listTags_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(meta_MetaService_listTags_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_createEdge(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "createEdge"; + auto func_ret_type = std::make_unique>("meta.ExecResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField meta_MetaService_createEdge_req_1; + meta_MetaService_createEdge_req_1.id_ref() = 1; + meta_MetaService_createEdge_req_1.name_ref() = "req"; + meta_MetaService_createEdge_req_1.is_optional_ref() = false; + auto meta_MetaService_createEdge_req_1_type = std::make_unique>("meta.CreateEdgeReq"); + meta_MetaService_createEdge_req_1_type->writeAndGenType(*meta_MetaService_createEdge_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(meta_MetaService_createEdge_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_alterEdge(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "alterEdge"; + auto func_ret_type = std::make_unique>("meta.ExecResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField meta_MetaService_alterEdge_req_1; + meta_MetaService_alterEdge_req_1.id_ref() = 1; + meta_MetaService_alterEdge_req_1.name_ref() = "req"; + meta_MetaService_alterEdge_req_1.is_optional_ref() = false; + auto meta_MetaService_alterEdge_req_1_type = std::make_unique>("meta.AlterEdgeReq"); + meta_MetaService_alterEdge_req_1_type->writeAndGenType(*meta_MetaService_alterEdge_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(meta_MetaService_alterEdge_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_dropEdge(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "dropEdge"; + auto func_ret_type = std::make_unique>("meta.ExecResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField meta_MetaService_dropEdge_req_1; + meta_MetaService_dropEdge_req_1.id_ref() = 1; + meta_MetaService_dropEdge_req_1.name_ref() = "req"; + meta_MetaService_dropEdge_req_1.is_optional_ref() = false; + auto meta_MetaService_dropEdge_req_1_type = std::make_unique>("meta.DropEdgeReq"); + meta_MetaService_dropEdge_req_1_type->writeAndGenType(*meta_MetaService_dropEdge_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(meta_MetaService_dropEdge_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_getEdge(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "getEdge"; + auto func_ret_type = std::make_unique>("meta.GetEdgeResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField meta_MetaService_getEdge_req_1; + meta_MetaService_getEdge_req_1.id_ref() = 1; + meta_MetaService_getEdge_req_1.name_ref() = "req"; + meta_MetaService_getEdge_req_1.is_optional_ref() = false; + auto meta_MetaService_getEdge_req_1_type = std::make_unique>("meta.GetEdgeReq"); + meta_MetaService_getEdge_req_1_type->writeAndGenType(*meta_MetaService_getEdge_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(meta_MetaService_getEdge_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_listEdges(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "listEdges"; + auto func_ret_type = std::make_unique>("meta.ListEdgesResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField meta_MetaService_listEdges_req_1; + meta_MetaService_listEdges_req_1.id_ref() = 1; + meta_MetaService_listEdges_req_1.name_ref() = "req"; + meta_MetaService_listEdges_req_1.is_optional_ref() = false; + auto meta_MetaService_listEdges_req_1_type = std::make_unique>("meta.ListEdgesReq"); + meta_MetaService_listEdges_req_1_type->writeAndGenType(*meta_MetaService_listEdges_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(meta_MetaService_listEdges_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_listHosts(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "listHosts"; + auto func_ret_type = std::make_unique>("meta.ListHostsResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField meta_MetaService_listHosts_req_1; + meta_MetaService_listHosts_req_1.id_ref() = 1; + meta_MetaService_listHosts_req_1.name_ref() = "req"; + meta_MetaService_listHosts_req_1.is_optional_ref() = false; + auto meta_MetaService_listHosts_req_1_type = std::make_unique>("meta.ListHostsReq"); + meta_MetaService_listHosts_req_1_type->writeAndGenType(*meta_MetaService_listHosts_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(meta_MetaService_listHosts_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_getPartsAlloc(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "getPartsAlloc"; + auto func_ret_type = std::make_unique>("meta.GetPartsAllocResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField meta_MetaService_getPartsAlloc_req_1; + meta_MetaService_getPartsAlloc_req_1.id_ref() = 1; + meta_MetaService_getPartsAlloc_req_1.name_ref() = "req"; + meta_MetaService_getPartsAlloc_req_1.is_optional_ref() = false; + auto meta_MetaService_getPartsAlloc_req_1_type = std::make_unique>("meta.GetPartsAllocReq"); + meta_MetaService_getPartsAlloc_req_1_type->writeAndGenType(*meta_MetaService_getPartsAlloc_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(meta_MetaService_getPartsAlloc_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_listParts(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "listParts"; + auto func_ret_type = std::make_unique>("meta.ListPartsResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField meta_MetaService_listParts_req_1; + meta_MetaService_listParts_req_1.id_ref() = 1; + meta_MetaService_listParts_req_1.name_ref() = "req"; + meta_MetaService_listParts_req_1.is_optional_ref() = false; + auto meta_MetaService_listParts_req_1_type = std::make_unique>("meta.ListPartsReq"); + meta_MetaService_listParts_req_1_type->writeAndGenType(*meta_MetaService_listParts_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(meta_MetaService_listParts_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_multiPut(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "multiPut"; + auto func_ret_type = std::make_unique>("meta.ExecResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField meta_MetaService_multiPut_req_1; + meta_MetaService_multiPut_req_1.id_ref() = 1; + meta_MetaService_multiPut_req_1.name_ref() = "req"; + meta_MetaService_multiPut_req_1.is_optional_ref() = false; + auto meta_MetaService_multiPut_req_1_type = std::make_unique>("meta.MultiPutReq"); + meta_MetaService_multiPut_req_1_type->writeAndGenType(*meta_MetaService_multiPut_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(meta_MetaService_multiPut_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_get(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "get"; + auto func_ret_type = std::make_unique>("meta.GetResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField meta_MetaService_get_req_1; + meta_MetaService_get_req_1.id_ref() = 1; + meta_MetaService_get_req_1.name_ref() = "req"; + meta_MetaService_get_req_1.is_optional_ref() = false; + auto meta_MetaService_get_req_1_type = std::make_unique>("meta.GetReq"); + meta_MetaService_get_req_1_type->writeAndGenType(*meta_MetaService_get_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(meta_MetaService_get_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_multiGet(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "multiGet"; + auto func_ret_type = std::make_unique>("meta.MultiGetResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField meta_MetaService_multiGet_req_1; + meta_MetaService_multiGet_req_1.id_ref() = 1; + meta_MetaService_multiGet_req_1.name_ref() = "req"; + meta_MetaService_multiGet_req_1.is_optional_ref() = false; + auto meta_MetaService_multiGet_req_1_type = std::make_unique>("meta.MultiGetReq"); + meta_MetaService_multiGet_req_1_type->writeAndGenType(*meta_MetaService_multiGet_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(meta_MetaService_multiGet_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_remove(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "remove"; + auto func_ret_type = std::make_unique>("meta.ExecResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField meta_MetaService_remove_req_1; + meta_MetaService_remove_req_1.id_ref() = 1; + meta_MetaService_remove_req_1.name_ref() = "req"; + meta_MetaService_remove_req_1.is_optional_ref() = false; + auto meta_MetaService_remove_req_1_type = std::make_unique>("meta.RemoveReq"); + meta_MetaService_remove_req_1_type->writeAndGenType(*meta_MetaService_remove_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(meta_MetaService_remove_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_removeRange(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "removeRange"; + auto func_ret_type = std::make_unique>("meta.ExecResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField meta_MetaService_removeRange_req_1; + meta_MetaService_removeRange_req_1.id_ref() = 1; + meta_MetaService_removeRange_req_1.name_ref() = "req"; + meta_MetaService_removeRange_req_1.is_optional_ref() = false; + auto meta_MetaService_removeRange_req_1_type = std::make_unique>("meta.RemoveRangeReq"); + meta_MetaService_removeRange_req_1_type->writeAndGenType(*meta_MetaService_removeRange_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(meta_MetaService_removeRange_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_scan(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "scan"; + auto func_ret_type = std::make_unique>("meta.ScanResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField meta_MetaService_scan_req_1; + meta_MetaService_scan_req_1.id_ref() = 1; + meta_MetaService_scan_req_1.name_ref() = "req"; + meta_MetaService_scan_req_1.is_optional_ref() = false; + auto meta_MetaService_scan_req_1_type = std::make_unique>("meta.ScanReq"); + meta_MetaService_scan_req_1_type->writeAndGenType(*meta_MetaService_scan_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(meta_MetaService_scan_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_createTagIndex(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "createTagIndex"; + auto func_ret_type = std::make_unique>("meta.ExecResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField meta_MetaService_createTagIndex_req_1; + meta_MetaService_createTagIndex_req_1.id_ref() = 1; + meta_MetaService_createTagIndex_req_1.name_ref() = "req"; + meta_MetaService_createTagIndex_req_1.is_optional_ref() = false; + auto meta_MetaService_createTagIndex_req_1_type = std::make_unique>("meta.CreateTagIndexReq"); + meta_MetaService_createTagIndex_req_1_type->writeAndGenType(*meta_MetaService_createTagIndex_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(meta_MetaService_createTagIndex_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_dropTagIndex(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "dropTagIndex"; + auto func_ret_type = std::make_unique>("meta.ExecResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField meta_MetaService_dropTagIndex_req_1; + meta_MetaService_dropTagIndex_req_1.id_ref() = 1; + meta_MetaService_dropTagIndex_req_1.name_ref() = "req"; + meta_MetaService_dropTagIndex_req_1.is_optional_ref() = false; + auto meta_MetaService_dropTagIndex_req_1_type = std::make_unique>("meta.DropTagIndexReq"); + meta_MetaService_dropTagIndex_req_1_type->writeAndGenType(*meta_MetaService_dropTagIndex_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(meta_MetaService_dropTagIndex_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_getTagIndex(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "getTagIndex"; + auto func_ret_type = std::make_unique>("meta.GetTagIndexResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField meta_MetaService_getTagIndex_req_1; + meta_MetaService_getTagIndex_req_1.id_ref() = 1; + meta_MetaService_getTagIndex_req_1.name_ref() = "req"; + meta_MetaService_getTagIndex_req_1.is_optional_ref() = false; + auto meta_MetaService_getTagIndex_req_1_type = std::make_unique>("meta.GetTagIndexReq"); + meta_MetaService_getTagIndex_req_1_type->writeAndGenType(*meta_MetaService_getTagIndex_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(meta_MetaService_getTagIndex_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_listTagIndexes(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "listTagIndexes"; + auto func_ret_type = std::make_unique>("meta.ListTagIndexesResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField meta_MetaService_listTagIndexes_req_1; + meta_MetaService_listTagIndexes_req_1.id_ref() = 1; + meta_MetaService_listTagIndexes_req_1.name_ref() = "req"; + meta_MetaService_listTagIndexes_req_1.is_optional_ref() = false; + auto meta_MetaService_listTagIndexes_req_1_type = std::make_unique>("meta.ListTagIndexesReq"); + meta_MetaService_listTagIndexes_req_1_type->writeAndGenType(*meta_MetaService_listTagIndexes_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(meta_MetaService_listTagIndexes_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_rebuildTagIndex(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "rebuildTagIndex"; + auto func_ret_type = std::make_unique>("meta.ExecResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField meta_MetaService_rebuildTagIndex_req_1; + meta_MetaService_rebuildTagIndex_req_1.id_ref() = 1; + meta_MetaService_rebuildTagIndex_req_1.name_ref() = "req"; + meta_MetaService_rebuildTagIndex_req_1.is_optional_ref() = false; + auto meta_MetaService_rebuildTagIndex_req_1_type = std::make_unique>("meta.RebuildIndexReq"); + meta_MetaService_rebuildTagIndex_req_1_type->writeAndGenType(*meta_MetaService_rebuildTagIndex_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(meta_MetaService_rebuildTagIndex_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_listTagIndexStatus(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "listTagIndexStatus"; + auto func_ret_type = std::make_unique>("meta.ListIndexStatusResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField meta_MetaService_listTagIndexStatus_req_1; + meta_MetaService_listTagIndexStatus_req_1.id_ref() = 1; + meta_MetaService_listTagIndexStatus_req_1.name_ref() = "req"; + meta_MetaService_listTagIndexStatus_req_1.is_optional_ref() = false; + auto meta_MetaService_listTagIndexStatus_req_1_type = std::make_unique>("meta.ListIndexStatusReq"); + meta_MetaService_listTagIndexStatus_req_1_type->writeAndGenType(*meta_MetaService_listTagIndexStatus_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(meta_MetaService_listTagIndexStatus_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_createEdgeIndex(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "createEdgeIndex"; + auto func_ret_type = std::make_unique>("meta.ExecResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField meta_MetaService_createEdgeIndex_req_1; + meta_MetaService_createEdgeIndex_req_1.id_ref() = 1; + meta_MetaService_createEdgeIndex_req_1.name_ref() = "req"; + meta_MetaService_createEdgeIndex_req_1.is_optional_ref() = false; + auto meta_MetaService_createEdgeIndex_req_1_type = std::make_unique>("meta.CreateEdgeIndexReq"); + meta_MetaService_createEdgeIndex_req_1_type->writeAndGenType(*meta_MetaService_createEdgeIndex_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(meta_MetaService_createEdgeIndex_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_dropEdgeIndex(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "dropEdgeIndex"; + auto func_ret_type = std::make_unique>("meta.ExecResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField meta_MetaService_dropEdgeIndex_req_1; + meta_MetaService_dropEdgeIndex_req_1.id_ref() = 1; + meta_MetaService_dropEdgeIndex_req_1.name_ref() = "req"; + meta_MetaService_dropEdgeIndex_req_1.is_optional_ref() = false; + auto meta_MetaService_dropEdgeIndex_req_1_type = std::make_unique>("meta.DropEdgeIndexReq"); + meta_MetaService_dropEdgeIndex_req_1_type->writeAndGenType(*meta_MetaService_dropEdgeIndex_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(meta_MetaService_dropEdgeIndex_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_getEdgeIndex(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "getEdgeIndex"; + auto func_ret_type = std::make_unique>("meta.GetEdgeIndexResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField meta_MetaService_getEdgeIndex_req_1; + meta_MetaService_getEdgeIndex_req_1.id_ref() = 1; + meta_MetaService_getEdgeIndex_req_1.name_ref() = "req"; + meta_MetaService_getEdgeIndex_req_1.is_optional_ref() = false; + auto meta_MetaService_getEdgeIndex_req_1_type = std::make_unique>("meta.GetEdgeIndexReq"); + meta_MetaService_getEdgeIndex_req_1_type->writeAndGenType(*meta_MetaService_getEdgeIndex_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(meta_MetaService_getEdgeIndex_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_listEdgeIndexes(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "listEdgeIndexes"; + auto func_ret_type = std::make_unique>("meta.ListEdgeIndexesResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField meta_MetaService_listEdgeIndexes_req_1; + meta_MetaService_listEdgeIndexes_req_1.id_ref() = 1; + meta_MetaService_listEdgeIndexes_req_1.name_ref() = "req"; + meta_MetaService_listEdgeIndexes_req_1.is_optional_ref() = false; + auto meta_MetaService_listEdgeIndexes_req_1_type = std::make_unique>("meta.ListEdgeIndexesReq"); + meta_MetaService_listEdgeIndexes_req_1_type->writeAndGenType(*meta_MetaService_listEdgeIndexes_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(meta_MetaService_listEdgeIndexes_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_rebuildEdgeIndex(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "rebuildEdgeIndex"; + auto func_ret_type = std::make_unique>("meta.ExecResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField meta_MetaService_rebuildEdgeIndex_req_1; + meta_MetaService_rebuildEdgeIndex_req_1.id_ref() = 1; + meta_MetaService_rebuildEdgeIndex_req_1.name_ref() = "req"; + meta_MetaService_rebuildEdgeIndex_req_1.is_optional_ref() = false; + auto meta_MetaService_rebuildEdgeIndex_req_1_type = std::make_unique>("meta.RebuildIndexReq"); + meta_MetaService_rebuildEdgeIndex_req_1_type->writeAndGenType(*meta_MetaService_rebuildEdgeIndex_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(meta_MetaService_rebuildEdgeIndex_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_listEdgeIndexStatus(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "listEdgeIndexStatus"; + auto func_ret_type = std::make_unique>("meta.ListIndexStatusResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField meta_MetaService_listEdgeIndexStatus_req_1; + meta_MetaService_listEdgeIndexStatus_req_1.id_ref() = 1; + meta_MetaService_listEdgeIndexStatus_req_1.name_ref() = "req"; + meta_MetaService_listEdgeIndexStatus_req_1.is_optional_ref() = false; + auto meta_MetaService_listEdgeIndexStatus_req_1_type = std::make_unique>("meta.ListIndexStatusReq"); + meta_MetaService_listEdgeIndexStatus_req_1_type->writeAndGenType(*meta_MetaService_listEdgeIndexStatus_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(meta_MetaService_listEdgeIndexStatus_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_createUser(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "createUser"; + auto func_ret_type = std::make_unique>("meta.ExecResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField meta_MetaService_createUser_req_1; + meta_MetaService_createUser_req_1.id_ref() = 1; + meta_MetaService_createUser_req_1.name_ref() = "req"; + meta_MetaService_createUser_req_1.is_optional_ref() = false; + auto meta_MetaService_createUser_req_1_type = std::make_unique>("meta.CreateUserReq"); + meta_MetaService_createUser_req_1_type->writeAndGenType(*meta_MetaService_createUser_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(meta_MetaService_createUser_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_dropUser(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "dropUser"; + auto func_ret_type = std::make_unique>("meta.ExecResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField meta_MetaService_dropUser_req_1; + meta_MetaService_dropUser_req_1.id_ref() = 1; + meta_MetaService_dropUser_req_1.name_ref() = "req"; + meta_MetaService_dropUser_req_1.is_optional_ref() = false; + auto meta_MetaService_dropUser_req_1_type = std::make_unique>("meta.DropUserReq"); + meta_MetaService_dropUser_req_1_type->writeAndGenType(*meta_MetaService_dropUser_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(meta_MetaService_dropUser_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_alterUser(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "alterUser"; + auto func_ret_type = std::make_unique>("meta.ExecResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField meta_MetaService_alterUser_req_1; + meta_MetaService_alterUser_req_1.id_ref() = 1; + meta_MetaService_alterUser_req_1.name_ref() = "req"; + meta_MetaService_alterUser_req_1.is_optional_ref() = false; + auto meta_MetaService_alterUser_req_1_type = std::make_unique>("meta.AlterUserReq"); + meta_MetaService_alterUser_req_1_type->writeAndGenType(*meta_MetaService_alterUser_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(meta_MetaService_alterUser_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_grantRole(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "grantRole"; + auto func_ret_type = std::make_unique>("meta.ExecResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField meta_MetaService_grantRole_req_1; + meta_MetaService_grantRole_req_1.id_ref() = 1; + meta_MetaService_grantRole_req_1.name_ref() = "req"; + meta_MetaService_grantRole_req_1.is_optional_ref() = false; + auto meta_MetaService_grantRole_req_1_type = std::make_unique>("meta.GrantRoleReq"); + meta_MetaService_grantRole_req_1_type->writeAndGenType(*meta_MetaService_grantRole_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(meta_MetaService_grantRole_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_revokeRole(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "revokeRole"; + auto func_ret_type = std::make_unique>("meta.ExecResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField meta_MetaService_revokeRole_req_1; + meta_MetaService_revokeRole_req_1.id_ref() = 1; + meta_MetaService_revokeRole_req_1.name_ref() = "req"; + meta_MetaService_revokeRole_req_1.is_optional_ref() = false; + auto meta_MetaService_revokeRole_req_1_type = std::make_unique>("meta.RevokeRoleReq"); + meta_MetaService_revokeRole_req_1_type->writeAndGenType(*meta_MetaService_revokeRole_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(meta_MetaService_revokeRole_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_listUsers(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "listUsers"; + auto func_ret_type = std::make_unique>("meta.ListUsersResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField meta_MetaService_listUsers_req_1; + meta_MetaService_listUsers_req_1.id_ref() = 1; + meta_MetaService_listUsers_req_1.name_ref() = "req"; + meta_MetaService_listUsers_req_1.is_optional_ref() = false; + auto meta_MetaService_listUsers_req_1_type = std::make_unique>("meta.ListUsersReq"); + meta_MetaService_listUsers_req_1_type->writeAndGenType(*meta_MetaService_listUsers_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(meta_MetaService_listUsers_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_listRoles(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "listRoles"; + auto func_ret_type = std::make_unique>("meta.ListRolesResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField meta_MetaService_listRoles_req_1; + meta_MetaService_listRoles_req_1.id_ref() = 1; + meta_MetaService_listRoles_req_1.name_ref() = "req"; + meta_MetaService_listRoles_req_1.is_optional_ref() = false; + auto meta_MetaService_listRoles_req_1_type = std::make_unique>("meta.ListRolesReq"); + meta_MetaService_listRoles_req_1_type->writeAndGenType(*meta_MetaService_listRoles_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(meta_MetaService_listRoles_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_getUserRoles(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "getUserRoles"; + auto func_ret_type = std::make_unique>("meta.ListRolesResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField meta_MetaService_getUserRoles_req_1; + meta_MetaService_getUserRoles_req_1.id_ref() = 1; + meta_MetaService_getUserRoles_req_1.name_ref() = "req"; + meta_MetaService_getUserRoles_req_1.is_optional_ref() = false; + auto meta_MetaService_getUserRoles_req_1_type = std::make_unique>("meta.GetUserRolesReq"); + meta_MetaService_getUserRoles_req_1_type->writeAndGenType(*meta_MetaService_getUserRoles_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(meta_MetaService_getUserRoles_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_changePassword(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "changePassword"; + auto func_ret_type = std::make_unique>("meta.ExecResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField meta_MetaService_changePassword_req_1; + meta_MetaService_changePassword_req_1.id_ref() = 1; + meta_MetaService_changePassword_req_1.name_ref() = "req"; + meta_MetaService_changePassword_req_1.is_optional_ref() = false; + auto meta_MetaService_changePassword_req_1_type = std::make_unique>("meta.ChangePasswordReq"); + meta_MetaService_changePassword_req_1_type->writeAndGenType(*meta_MetaService_changePassword_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(meta_MetaService_changePassword_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_heartBeat(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "heartBeat"; + auto func_ret_type = std::make_unique>("meta.HBResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField meta_MetaService_heartBeat_req_1; + meta_MetaService_heartBeat_req_1.id_ref() = 1; + meta_MetaService_heartBeat_req_1.name_ref() = "req"; + meta_MetaService_heartBeat_req_1.is_optional_ref() = false; + auto meta_MetaService_heartBeat_req_1_type = std::make_unique>("meta.HBReq"); + meta_MetaService_heartBeat_req_1_type->writeAndGenType(*meta_MetaService_heartBeat_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(meta_MetaService_heartBeat_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_balance(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "balance"; + auto func_ret_type = std::make_unique>("meta.BalanceResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField meta_MetaService_balance_req_1; + meta_MetaService_balance_req_1.id_ref() = 1; + meta_MetaService_balance_req_1.name_ref() = "req"; + meta_MetaService_balance_req_1.is_optional_ref() = false; + auto meta_MetaService_balance_req_1_type = std::make_unique>("meta.BalanceReq"); + meta_MetaService_balance_req_1_type->writeAndGenType(*meta_MetaService_balance_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(meta_MetaService_balance_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_leaderBalance(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "leaderBalance"; + auto func_ret_type = std::make_unique>("meta.ExecResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField meta_MetaService_leaderBalance_req_1; + meta_MetaService_leaderBalance_req_1.id_ref() = 1; + meta_MetaService_leaderBalance_req_1.name_ref() = "req"; + meta_MetaService_leaderBalance_req_1.is_optional_ref() = false; + auto meta_MetaService_leaderBalance_req_1_type = std::make_unique>("meta.LeaderBalanceReq"); + meta_MetaService_leaderBalance_req_1_type->writeAndGenType(*meta_MetaService_leaderBalance_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(meta_MetaService_leaderBalance_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_regConfig(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "regConfig"; + auto func_ret_type = std::make_unique>("meta.ExecResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField meta_MetaService_regConfig_req_1; + meta_MetaService_regConfig_req_1.id_ref() = 1; + meta_MetaService_regConfig_req_1.name_ref() = "req"; + meta_MetaService_regConfig_req_1.is_optional_ref() = false; + auto meta_MetaService_regConfig_req_1_type = std::make_unique>("meta.RegConfigReq"); + meta_MetaService_regConfig_req_1_type->writeAndGenType(*meta_MetaService_regConfig_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(meta_MetaService_regConfig_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_getConfig(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "getConfig"; + auto func_ret_type = std::make_unique>("meta.GetConfigResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField meta_MetaService_getConfig_req_1; + meta_MetaService_getConfig_req_1.id_ref() = 1; + meta_MetaService_getConfig_req_1.name_ref() = "req"; + meta_MetaService_getConfig_req_1.is_optional_ref() = false; + auto meta_MetaService_getConfig_req_1_type = std::make_unique>("meta.GetConfigReq"); + meta_MetaService_getConfig_req_1_type->writeAndGenType(*meta_MetaService_getConfig_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(meta_MetaService_getConfig_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_setConfig(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "setConfig"; + auto func_ret_type = std::make_unique>("meta.ExecResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField meta_MetaService_setConfig_req_1; + meta_MetaService_setConfig_req_1.id_ref() = 1; + meta_MetaService_setConfig_req_1.name_ref() = "req"; + meta_MetaService_setConfig_req_1.is_optional_ref() = false; + auto meta_MetaService_setConfig_req_1_type = std::make_unique>("meta.SetConfigReq"); + meta_MetaService_setConfig_req_1_type->writeAndGenType(*meta_MetaService_setConfig_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(meta_MetaService_setConfig_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_listConfigs(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "listConfigs"; + auto func_ret_type = std::make_unique>("meta.ListConfigsResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField meta_MetaService_listConfigs_req_1; + meta_MetaService_listConfigs_req_1.id_ref() = 1; + meta_MetaService_listConfigs_req_1.name_ref() = "req"; + meta_MetaService_listConfigs_req_1.is_optional_ref() = false; + auto meta_MetaService_listConfigs_req_1_type = std::make_unique>("meta.ListConfigsReq"); + meta_MetaService_listConfigs_req_1_type->writeAndGenType(*meta_MetaService_listConfigs_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(meta_MetaService_listConfigs_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_createSnapshot(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "createSnapshot"; + auto func_ret_type = std::make_unique>("meta.ExecResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField meta_MetaService_createSnapshot_req_1; + meta_MetaService_createSnapshot_req_1.id_ref() = 1; + meta_MetaService_createSnapshot_req_1.name_ref() = "req"; + meta_MetaService_createSnapshot_req_1.is_optional_ref() = false; + auto meta_MetaService_createSnapshot_req_1_type = std::make_unique>("meta.CreateSnapshotReq"); + meta_MetaService_createSnapshot_req_1_type->writeAndGenType(*meta_MetaService_createSnapshot_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(meta_MetaService_createSnapshot_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_dropSnapshot(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "dropSnapshot"; + auto func_ret_type = std::make_unique>("meta.ExecResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField meta_MetaService_dropSnapshot_req_1; + meta_MetaService_dropSnapshot_req_1.id_ref() = 1; + meta_MetaService_dropSnapshot_req_1.name_ref() = "req"; + meta_MetaService_dropSnapshot_req_1.is_optional_ref() = false; + auto meta_MetaService_dropSnapshot_req_1_type = std::make_unique>("meta.DropSnapshotReq"); + meta_MetaService_dropSnapshot_req_1_type->writeAndGenType(*meta_MetaService_dropSnapshot_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(meta_MetaService_dropSnapshot_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_listSnapshots(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "listSnapshots"; + auto func_ret_type = std::make_unique>("meta.ListSnapshotsResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField meta_MetaService_listSnapshots_req_1; + meta_MetaService_listSnapshots_req_1.id_ref() = 1; + meta_MetaService_listSnapshots_req_1.name_ref() = "req"; + meta_MetaService_listSnapshots_req_1.is_optional_ref() = false; + auto meta_MetaService_listSnapshots_req_1_type = std::make_unique>("meta.ListSnapshotsReq"); + meta_MetaService_listSnapshots_req_1_type->writeAndGenType(*meta_MetaService_listSnapshots_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(meta_MetaService_listSnapshots_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_runAdminJob(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "runAdminJob"; + auto func_ret_type = std::make_unique>("meta.AdminJobResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField meta_MetaService_runAdminJob_req_1; + meta_MetaService_runAdminJob_req_1.id_ref() = 1; + meta_MetaService_runAdminJob_req_1.name_ref() = "req"; + meta_MetaService_runAdminJob_req_1.is_optional_ref() = false; + auto meta_MetaService_runAdminJob_req_1_type = std::make_unique>("meta.AdminJobReq"); + meta_MetaService_runAdminJob_req_1_type->writeAndGenType(*meta_MetaService_runAdminJob_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(meta_MetaService_runAdminJob_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_addZone(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "addZone"; + auto func_ret_type = std::make_unique>("meta.ExecResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField meta_MetaService_addZone_req_1; + meta_MetaService_addZone_req_1.id_ref() = 1; + meta_MetaService_addZone_req_1.name_ref() = "req"; + meta_MetaService_addZone_req_1.is_optional_ref() = false; + auto meta_MetaService_addZone_req_1_type = std::make_unique>("meta.AddZoneReq"); + meta_MetaService_addZone_req_1_type->writeAndGenType(*meta_MetaService_addZone_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(meta_MetaService_addZone_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_dropZone(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "dropZone"; + auto func_ret_type = std::make_unique>("meta.ExecResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField meta_MetaService_dropZone_req_1; + meta_MetaService_dropZone_req_1.id_ref() = 1; + meta_MetaService_dropZone_req_1.name_ref() = "req"; + meta_MetaService_dropZone_req_1.is_optional_ref() = false; + auto meta_MetaService_dropZone_req_1_type = std::make_unique>("meta.DropZoneReq"); + meta_MetaService_dropZone_req_1_type->writeAndGenType(*meta_MetaService_dropZone_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(meta_MetaService_dropZone_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_addHostIntoZone(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "addHostIntoZone"; + auto func_ret_type = std::make_unique>("meta.ExecResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField meta_MetaService_addHostIntoZone_req_1; + meta_MetaService_addHostIntoZone_req_1.id_ref() = 1; + meta_MetaService_addHostIntoZone_req_1.name_ref() = "req"; + meta_MetaService_addHostIntoZone_req_1.is_optional_ref() = false; + auto meta_MetaService_addHostIntoZone_req_1_type = std::make_unique>("meta.AddHostIntoZoneReq"); + meta_MetaService_addHostIntoZone_req_1_type->writeAndGenType(*meta_MetaService_addHostIntoZone_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(meta_MetaService_addHostIntoZone_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_dropHostFromZone(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "dropHostFromZone"; + auto func_ret_type = std::make_unique>("meta.ExecResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField meta_MetaService_dropHostFromZone_req_1; + meta_MetaService_dropHostFromZone_req_1.id_ref() = 1; + meta_MetaService_dropHostFromZone_req_1.name_ref() = "req"; + meta_MetaService_dropHostFromZone_req_1.is_optional_ref() = false; + auto meta_MetaService_dropHostFromZone_req_1_type = std::make_unique>("meta.DropHostFromZoneReq"); + meta_MetaService_dropHostFromZone_req_1_type->writeAndGenType(*meta_MetaService_dropHostFromZone_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(meta_MetaService_dropHostFromZone_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_getZone(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "getZone"; + auto func_ret_type = std::make_unique>("meta.GetZoneResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField meta_MetaService_getZone_req_1; + meta_MetaService_getZone_req_1.id_ref() = 1; + meta_MetaService_getZone_req_1.name_ref() = "req"; + meta_MetaService_getZone_req_1.is_optional_ref() = false; + auto meta_MetaService_getZone_req_1_type = std::make_unique>("meta.GetZoneReq"); + meta_MetaService_getZone_req_1_type->writeAndGenType(*meta_MetaService_getZone_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(meta_MetaService_getZone_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_listZones(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "listZones"; + auto func_ret_type = std::make_unique>("meta.ListZonesResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField meta_MetaService_listZones_req_1; + meta_MetaService_listZones_req_1.id_ref() = 1; + meta_MetaService_listZones_req_1.name_ref() = "req"; + meta_MetaService_listZones_req_1.is_optional_ref() = false; + auto meta_MetaService_listZones_req_1_type = std::make_unique>("meta.ListZonesReq"); + meta_MetaService_listZones_req_1_type->writeAndGenType(*meta_MetaService_listZones_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(meta_MetaService_listZones_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_addGroup(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "addGroup"; + auto func_ret_type = std::make_unique>("meta.ExecResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField meta_MetaService_addGroup_req_1; + meta_MetaService_addGroup_req_1.id_ref() = 1; + meta_MetaService_addGroup_req_1.name_ref() = "req"; + meta_MetaService_addGroup_req_1.is_optional_ref() = false; + auto meta_MetaService_addGroup_req_1_type = std::make_unique>("meta.AddGroupReq"); + meta_MetaService_addGroup_req_1_type->writeAndGenType(*meta_MetaService_addGroup_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(meta_MetaService_addGroup_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_dropGroup(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "dropGroup"; + auto func_ret_type = std::make_unique>("meta.ExecResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField meta_MetaService_dropGroup_req_1; + meta_MetaService_dropGroup_req_1.id_ref() = 1; + meta_MetaService_dropGroup_req_1.name_ref() = "req"; + meta_MetaService_dropGroup_req_1.is_optional_ref() = false; + auto meta_MetaService_dropGroup_req_1_type = std::make_unique>("meta.DropGroupReq"); + meta_MetaService_dropGroup_req_1_type->writeAndGenType(*meta_MetaService_dropGroup_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(meta_MetaService_dropGroup_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_addZoneIntoGroup(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "addZoneIntoGroup"; + auto func_ret_type = std::make_unique>("meta.ExecResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField meta_MetaService_addZoneIntoGroup_req_1; + meta_MetaService_addZoneIntoGroup_req_1.id_ref() = 1; + meta_MetaService_addZoneIntoGroup_req_1.name_ref() = "req"; + meta_MetaService_addZoneIntoGroup_req_1.is_optional_ref() = false; + auto meta_MetaService_addZoneIntoGroup_req_1_type = std::make_unique>("meta.AddZoneIntoGroupReq"); + meta_MetaService_addZoneIntoGroup_req_1_type->writeAndGenType(*meta_MetaService_addZoneIntoGroup_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(meta_MetaService_addZoneIntoGroup_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_dropZoneFromGroup(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "dropZoneFromGroup"; + auto func_ret_type = std::make_unique>("meta.ExecResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField meta_MetaService_dropZoneFromGroup_req_1; + meta_MetaService_dropZoneFromGroup_req_1.id_ref() = 1; + meta_MetaService_dropZoneFromGroup_req_1.name_ref() = "req"; + meta_MetaService_dropZoneFromGroup_req_1.is_optional_ref() = false; + auto meta_MetaService_dropZoneFromGroup_req_1_type = std::make_unique>("meta.DropZoneFromGroupReq"); + meta_MetaService_dropZoneFromGroup_req_1_type->writeAndGenType(*meta_MetaService_dropZoneFromGroup_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(meta_MetaService_dropZoneFromGroup_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_getGroup(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "getGroup"; + auto func_ret_type = std::make_unique>("meta.GetGroupResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField meta_MetaService_getGroup_req_1; + meta_MetaService_getGroup_req_1.id_ref() = 1; + meta_MetaService_getGroup_req_1.name_ref() = "req"; + meta_MetaService_getGroup_req_1.is_optional_ref() = false; + auto meta_MetaService_getGroup_req_1_type = std::make_unique>("meta.GetGroupReq"); + meta_MetaService_getGroup_req_1_type->writeAndGenType(*meta_MetaService_getGroup_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(meta_MetaService_getGroup_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_listGroups(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "listGroups"; + auto func_ret_type = std::make_unique>("meta.ListGroupsResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField meta_MetaService_listGroups_req_1; + meta_MetaService_listGroups_req_1.id_ref() = 1; + meta_MetaService_listGroups_req_1.name_ref() = "req"; + meta_MetaService_listGroups_req_1.is_optional_ref() = false; + auto meta_MetaService_listGroups_req_1_type = std::make_unique>("meta.ListGroupsReq"); + meta_MetaService_listGroups_req_1_type->writeAndGenType(*meta_MetaService_listGroups_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(meta_MetaService_listGroups_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_createBackup(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "createBackup"; + auto func_ret_type = std::make_unique>("meta.CreateBackupResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField meta_MetaService_createBackup_req_1; + meta_MetaService_createBackup_req_1.id_ref() = 1; + meta_MetaService_createBackup_req_1.name_ref() = "req"; + meta_MetaService_createBackup_req_1.is_optional_ref() = false; + auto meta_MetaService_createBackup_req_1_type = std::make_unique>("meta.CreateBackupReq"); + meta_MetaService_createBackup_req_1_type->writeAndGenType(*meta_MetaService_createBackup_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(meta_MetaService_createBackup_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_restoreMeta(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "restoreMeta"; + auto func_ret_type = std::make_unique>("meta.ExecResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField meta_MetaService_restoreMeta_req_1; + meta_MetaService_restoreMeta_req_1.id_ref() = 1; + meta_MetaService_restoreMeta_req_1.name_ref() = "req"; + meta_MetaService_restoreMeta_req_1.is_optional_ref() = false; + auto meta_MetaService_restoreMeta_req_1_type = std::make_unique>("meta.RestoreMetaReq"); + meta_MetaService_restoreMeta_req_1_type->writeAndGenType(*meta_MetaService_restoreMeta_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(meta_MetaService_restoreMeta_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_addListener(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "addListener"; + auto func_ret_type = std::make_unique>("meta.ExecResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField meta_MetaService_addListener_req_1; + meta_MetaService_addListener_req_1.id_ref() = 1; + meta_MetaService_addListener_req_1.name_ref() = "req"; + meta_MetaService_addListener_req_1.is_optional_ref() = false; + auto meta_MetaService_addListener_req_1_type = std::make_unique>("meta.AddListenerReq"); + meta_MetaService_addListener_req_1_type->writeAndGenType(*meta_MetaService_addListener_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(meta_MetaService_addListener_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_removeListener(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "removeListener"; + auto func_ret_type = std::make_unique>("meta.ExecResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField meta_MetaService_removeListener_req_1; + meta_MetaService_removeListener_req_1.id_ref() = 1; + meta_MetaService_removeListener_req_1.name_ref() = "req"; + meta_MetaService_removeListener_req_1.is_optional_ref() = false; + auto meta_MetaService_removeListener_req_1_type = std::make_unique>("meta.RemoveListenerReq"); + meta_MetaService_removeListener_req_1_type->writeAndGenType(*meta_MetaService_removeListener_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(meta_MetaService_removeListener_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_listListener(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "listListener"; + auto func_ret_type = std::make_unique>("meta.ListListenerResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField meta_MetaService_listListener_req_1; + meta_MetaService_listListener_req_1.id_ref() = 1; + meta_MetaService_listListener_req_1.name_ref() = "req"; + meta_MetaService_listListener_req_1.is_optional_ref() = false; + auto meta_MetaService_listListener_req_1_type = std::make_unique>("meta.ListListenerReq"); + meta_MetaService_listListener_req_1_type->writeAndGenType(*meta_MetaService_listListener_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(meta_MetaService_listListener_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_getStats(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "getStats"; + auto func_ret_type = std::make_unique>("meta.GetStatsResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField meta_MetaService_getStats_req_1; + meta_MetaService_getStats_req_1.id_ref() = 1; + meta_MetaService_getStats_req_1.name_ref() = "req"; + meta_MetaService_getStats_req_1.is_optional_ref() = false; + auto meta_MetaService_getStats_req_1_type = std::make_unique>("meta.GetStatsReq"); + meta_MetaService_getStats_req_1_type->writeAndGenType(*meta_MetaService_getStats_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(meta_MetaService_getStats_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_signInFTService(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "signInFTService"; + auto func_ret_type = std::make_unique>("meta.ExecResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField meta_MetaService_signInFTService_req_1; + meta_MetaService_signInFTService_req_1.id_ref() = 1; + meta_MetaService_signInFTService_req_1.name_ref() = "req"; + meta_MetaService_signInFTService_req_1.is_optional_ref() = false; + auto meta_MetaService_signInFTService_req_1_type = std::make_unique>("meta.SignInFTServiceReq"); + meta_MetaService_signInFTService_req_1_type->writeAndGenType(*meta_MetaService_signInFTService_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(meta_MetaService_signInFTService_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_signOutFTService(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "signOutFTService"; + auto func_ret_type = std::make_unique>("meta.ExecResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField meta_MetaService_signOutFTService_req_1; + meta_MetaService_signOutFTService_req_1.id_ref() = 1; + meta_MetaService_signOutFTService_req_1.name_ref() = "req"; + meta_MetaService_signOutFTService_req_1.is_optional_ref() = false; + auto meta_MetaService_signOutFTService_req_1_type = std::make_unique>("meta.SignOutFTServiceReq"); + meta_MetaService_signOutFTService_req_1_type->writeAndGenType(*meta_MetaService_signOutFTService_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(meta_MetaService_signOutFTService_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_listFTClients(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "listFTClients"; + auto func_ret_type = std::make_unique>("meta.ListFTClientsResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField meta_MetaService_listFTClients_req_1; + meta_MetaService_listFTClients_req_1.id_ref() = 1; + meta_MetaService_listFTClients_req_1.name_ref() = "req"; + meta_MetaService_listFTClients_req_1.is_optional_ref() = false; + auto meta_MetaService_listFTClients_req_1_type = std::make_unique>("meta.ListFTClientsReq"); + meta_MetaService_listFTClients_req_1_type->writeAndGenType(*meta_MetaService_listFTClients_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(meta_MetaService_listFTClients_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_createFTIndex(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "createFTIndex"; + auto func_ret_type = std::make_unique>("meta.ExecResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField meta_MetaService_createFTIndex_req_1; + meta_MetaService_createFTIndex_req_1.id_ref() = 1; + meta_MetaService_createFTIndex_req_1.name_ref() = "req"; + meta_MetaService_createFTIndex_req_1.is_optional_ref() = false; + auto meta_MetaService_createFTIndex_req_1_type = std::make_unique>("meta.CreateFTIndexReq"); + meta_MetaService_createFTIndex_req_1_type->writeAndGenType(*meta_MetaService_createFTIndex_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(meta_MetaService_createFTIndex_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_dropFTIndex(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "dropFTIndex"; + auto func_ret_type = std::make_unique>("meta.ExecResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField meta_MetaService_dropFTIndex_req_1; + meta_MetaService_dropFTIndex_req_1.id_ref() = 1; + meta_MetaService_dropFTIndex_req_1.name_ref() = "req"; + meta_MetaService_dropFTIndex_req_1.is_optional_ref() = false; + auto meta_MetaService_dropFTIndex_req_1_type = std::make_unique>("meta.DropFTIndexReq"); + meta_MetaService_dropFTIndex_req_1_type->writeAndGenType(*meta_MetaService_dropFTIndex_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(meta_MetaService_dropFTIndex_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_listFTIndexes(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "listFTIndexes"; + auto func_ret_type = std::make_unique>("meta.ListFTIndexesResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField meta_MetaService_listFTIndexes_req_1; + meta_MetaService_listFTIndexes_req_1.id_ref() = 1; + meta_MetaService_listFTIndexes_req_1.name_ref() = "req"; + meta_MetaService_listFTIndexes_req_1.is_optional_ref() = false; + auto meta_MetaService_listFTIndexes_req_1_type = std::make_unique>("meta.ListFTIndexesReq"); + meta_MetaService_listFTIndexes_req_1_type->writeAndGenType(*meta_MetaService_listFTIndexes_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(meta_MetaService_listFTIndexes_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_createSession(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "createSession"; + auto func_ret_type = std::make_unique>("meta.CreateSessionResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField meta_MetaService_createSession_req_1; + meta_MetaService_createSession_req_1.id_ref() = 1; + meta_MetaService_createSession_req_1.name_ref() = "req"; + meta_MetaService_createSession_req_1.is_optional_ref() = false; + auto meta_MetaService_createSession_req_1_type = std::make_unique>("meta.CreateSessionReq"); + meta_MetaService_createSession_req_1_type->writeAndGenType(*meta_MetaService_createSession_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(meta_MetaService_createSession_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_updateSessions(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "updateSessions"; + auto func_ret_type = std::make_unique>("meta.UpdateSessionsResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField meta_MetaService_updateSessions_req_1; + meta_MetaService_updateSessions_req_1.id_ref() = 1; + meta_MetaService_updateSessions_req_1.name_ref() = "req"; + meta_MetaService_updateSessions_req_1.is_optional_ref() = false; + auto meta_MetaService_updateSessions_req_1_type = std::make_unique>("meta.UpdateSessionsReq"); + meta_MetaService_updateSessions_req_1_type->writeAndGenType(*meta_MetaService_updateSessions_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(meta_MetaService_updateSessions_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_listSessions(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "listSessions"; + auto func_ret_type = std::make_unique>("meta.ListSessionsResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField meta_MetaService_listSessions_req_1; + meta_MetaService_listSessions_req_1.id_ref() = 1; + meta_MetaService_listSessions_req_1.name_ref() = "req"; + meta_MetaService_listSessions_req_1.is_optional_ref() = false; + auto meta_MetaService_listSessions_req_1_type = std::make_unique>("meta.ListSessionsReq"); + meta_MetaService_listSessions_req_1_type->writeAndGenType(*meta_MetaService_listSessions_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(meta_MetaService_listSessions_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_getSession(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "getSession"; + auto func_ret_type = std::make_unique>("meta.GetSessionResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField meta_MetaService_getSession_req_1; + meta_MetaService_getSession_req_1.id_ref() = 1; + meta_MetaService_getSession_req_1.name_ref() = "req"; + meta_MetaService_getSession_req_1.is_optional_ref() = false; + auto meta_MetaService_getSession_req_1_type = std::make_unique>("meta.GetSessionReq"); + meta_MetaService_getSession_req_1_type->writeAndGenType(*meta_MetaService_getSession_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(meta_MetaService_getSession_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_removeSession(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "removeSession"; + auto func_ret_type = std::make_unique>("meta.ExecResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField meta_MetaService_removeSession_req_1; + meta_MetaService_removeSession_req_1.id_ref() = 1; + meta_MetaService_removeSession_req_1.name_ref() = "req"; + meta_MetaService_removeSession_req_1.is_optional_ref() = false; + auto meta_MetaService_removeSession_req_1_type = std::make_unique>("meta.RemoveSessionReq"); + meta_MetaService_removeSession_req_1_type->writeAndGenType(*meta_MetaService_removeSession_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(meta_MetaService_removeSession_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_killQuery(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "killQuery"; + auto func_ret_type = std::make_unique>("meta.ExecResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField meta_MetaService_killQuery_req_1; + meta_MetaService_killQuery_req_1.id_ref() = 1; + meta_MetaService_killQuery_req_1.name_ref() = "req"; + meta_MetaService_killQuery_req_1.is_optional_ref() = false; + auto meta_MetaService_killQuery_req_1_type = std::make_unique>("meta.KillQueryReq"); + meta_MetaService_killQuery_req_1_type->writeAndGenType(*meta_MetaService_killQuery_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(meta_MetaService_killQuery_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_reportTaskFinish(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "reportTaskFinish"; + auto func_ret_type = std::make_unique>("meta.ExecResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField meta_MetaService_reportTaskFinish_req_1; + meta_MetaService_reportTaskFinish_req_1.id_ref() = 1; + meta_MetaService_reportTaskFinish_req_1.name_ref() = "req"; + meta_MetaService_reportTaskFinish_req_1.is_optional_ref() = false; + auto meta_MetaService_reportTaskFinish_req_1_type = std::make_unique>("meta.ReportTaskReq"); + meta_MetaService_reportTaskFinish_req_1_type->writeAndGenType(*meta_MetaService_reportTaskFinish_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(meta_MetaService_reportTaskFinish_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_listCluster(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "listCluster"; + auto func_ret_type = std::make_unique>("meta.ListClusterInfoResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField meta_MetaService_listCluster_req_1; + meta_MetaService_listCluster_req_1.id_ref() = 1; + meta_MetaService_listCluster_req_1.name_ref() = "req"; + meta_MetaService_listCluster_req_1.is_optional_ref() = false; + auto meta_MetaService_listCluster_req_1_type = std::make_unique>("meta.ListClusterInfoReq"); + meta_MetaService_listCluster_req_1_type->writeAndGenType(*meta_MetaService_listCluster_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(meta_MetaService_listCluster_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_getMetaDirInfo(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "getMetaDirInfo"; + auto func_ret_type = std::make_unique>("meta.GetMetaDirInfoResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField meta_MetaService_getMetaDirInfo_req_1; + meta_MetaService_getMetaDirInfo_req_1.id_ref() = 1; + meta_MetaService_getMetaDirInfo_req_1.name_ref() = "req"; + meta_MetaService_getMetaDirInfo_req_1.is_optional_ref() = false; + auto meta_MetaService_getMetaDirInfo_req_1_type = std::make_unique>("meta.GetMetaDirInfoReq"); + meta_MetaService_getMetaDirInfo_req_1_type->writeAndGenType(*meta_MetaService_getMetaDirInfo_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(meta_MetaService_getMetaDirInfo_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_verifyClientVersion(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "verifyClientVersion"; + auto func_ret_type = std::make_unique>("meta.VerifyClientVersionResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField meta_MetaService_verifyClientVersion_req_1; + meta_MetaService_verifyClientVersion_req_1.id_ref() = 1; + meta_MetaService_verifyClientVersion_req_1.name_ref() = "req"; + meta_MetaService_verifyClientVersion_req_1.is_optional_ref() = false; + auto meta_MetaService_verifyClientVersion_req_1_type = std::make_unique>("meta.VerifyClientVersionReq"); + meta_MetaService_verifyClientVersion_req_1_type->writeAndGenType(*meta_MetaService_verifyClientVersion_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(meta_MetaService_verifyClientVersion_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} + +void ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen(ThriftMetadata& metadata, ThriftServiceContext& context) { + (void) metadata; + ::apache::thrift::metadata::ThriftService meta_MetaService; + meta_MetaService.name_ref() = "meta.MetaService"; + static const ThriftFunctionGenerator functions[] = { + ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_createSpace, + ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_dropSpace, + ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_getSpace, + ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_listSpaces, + ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_createSpaceAs, + ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_createTag, + ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_alterTag, + ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_dropTag, + ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_getTag, + ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_listTags, + ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_createEdge, + ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_alterEdge, + ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_dropEdge, + ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_getEdge, + ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_listEdges, + ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_listHosts, + ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_getPartsAlloc, + ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_listParts, + ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_multiPut, + ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_get, + ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_multiGet, + ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_remove, + ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_removeRange, + ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_scan, + ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_createTagIndex, + ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_dropTagIndex, + ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_getTagIndex, + ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_listTagIndexes, + ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_rebuildTagIndex, + ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_listTagIndexStatus, + ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_createEdgeIndex, + ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_dropEdgeIndex, + ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_getEdgeIndex, + ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_listEdgeIndexes, + ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_rebuildEdgeIndex, + ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_listEdgeIndexStatus, + ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_createUser, + ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_dropUser, + ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_alterUser, + ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_grantRole, + ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_revokeRole, + ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_listUsers, + ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_listRoles, + ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_getUserRoles, + ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_changePassword, + ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_heartBeat, + ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_balance, + ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_leaderBalance, + ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_regConfig, + ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_getConfig, + ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_setConfig, + ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_listConfigs, + ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_createSnapshot, + ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_dropSnapshot, + ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_listSnapshots, + ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_runAdminJob, + ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_addZone, + ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_dropZone, + ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_addHostIntoZone, + ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_dropHostFromZone, + ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_getZone, + ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_listZones, + ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_addGroup, + ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_dropGroup, + ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_addZoneIntoGroup, + ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_dropZoneFromGroup, + ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_getGroup, + ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_listGroups, + ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_createBackup, + ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_restoreMeta, + ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_addListener, + ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_removeListener, + ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_listListener, + ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_getStats, + ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_signInFTService, + ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_signOutFTService, + ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_listFTClients, + ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_createFTIndex, + ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_dropFTIndex, + ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_listFTIndexes, + ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_createSession, + ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_updateSessions, + ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_listSessions, + ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_getSession, + ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_removeSession, + ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_killQuery, + ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_reportTaskFinish, + ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_listCluster, + ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_getMetaDirInfo, + ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf>::gen_verifyClientVersion, + }; + for (auto& function_gen : functions) { + function_gen(metadata, meta_MetaService); + } + context.service_info_ref() = std::move(meta_MetaService); + ::apache::thrift::metadata::ThriftModuleContext module; + module.name_ref() = "meta"; + context.module_ref() = std::move(module); +} +} // namespace md +} // namespace detail +} // namespace thrift +} // namespace apache diff --git a/src/interface/gen-cpp2/meta_metadata.h b/src/interface/gen-cpp2/meta_metadata.h new file mode 100644 index 00000000..11541967 --- /dev/null +++ b/src/interface/gen-cpp2/meta_metadata.h @@ -0,0 +1,1053 @@ +/** + * Autogenerated by Thrift for meta.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#pragma once + +#include +#include "meta_types.h" +#include "common_metadata.h" + +namespace nebula { +namespace meta { +namespace cpp2 { +class MetaServiceSvIf; +}}} // namespace nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { +namespace md { + +template <> +class EnumMetadata<::nebula::meta::cpp2::AlterSchemaOp> { + public: + static void gen(ThriftMetadata& metadata); +}; +template <> +class EnumMetadata<::nebula::meta::cpp2::RoleType> { + public: + static void gen(ThriftMetadata& metadata); +}; +template <> +class EnumMetadata<::nebula::meta::cpp2::GeoShape> { + public: + static void gen(ThriftMetadata& metadata); +}; +template <> +class EnumMetadata<::nebula::meta::cpp2::PropertyType> { + public: + static void gen(ThriftMetadata& metadata); +}; +template <> +class EnumMetadata<::nebula::meta::cpp2::IsolationLevel> { + public: + static void gen(ThriftMetadata& metadata); +}; +template <> +class EnumMetadata<::nebula::meta::cpp2::HostStatus> { + public: + static void gen(ThriftMetadata& metadata); +}; +template <> +class EnumMetadata<::nebula::meta::cpp2::SnapshotStatus> { + public: + static void gen(ThriftMetadata& metadata); +}; +template <> +class EnumMetadata<::nebula::meta::cpp2::AdminJobOp> { + public: + static void gen(ThriftMetadata& metadata); +}; +template <> +class EnumMetadata<::nebula::meta::cpp2::AdminCmd> { + public: + static void gen(ThriftMetadata& metadata); +}; +template <> +class EnumMetadata<::nebula::meta::cpp2::JobStatus> { + public: + static void gen(ThriftMetadata& metadata); +}; +template <> +class EnumMetadata<::nebula::meta::cpp2::ListHostType> { + public: + static void gen(ThriftMetadata& metadata); +}; +template <> +class EnumMetadata<::nebula::meta::cpp2::HostRole> { + public: + static void gen(ThriftMetadata& metadata); +}; +template <> +class EnumMetadata<::nebula::meta::cpp2::TaskResult> { + public: + static void gen(ThriftMetadata& metadata); +}; +template <> +class EnumMetadata<::nebula::meta::cpp2::ConfigModule> { + public: + static void gen(ThriftMetadata& metadata); +}; +template <> +class EnumMetadata<::nebula::meta::cpp2::ConfigMode> { + public: + static void gen(ThriftMetadata& metadata); +}; +template <> +class EnumMetadata<::nebula::meta::cpp2::ListenerType> { + public: + static void gen(ThriftMetadata& metadata); +}; +template <> +class EnumMetadata<::nebula::meta::cpp2::FTServiceType> { + public: + static void gen(ThriftMetadata& metadata); +}; +template <> +class EnumMetadata<::nebula::meta::cpp2::QueryStatus> { + public: + static void gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::ID> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::ColumnTypeDef> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::ColumnDef> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::SchemaProp> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::Schema> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::IdName> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::SpaceDesc> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::SpaceItem> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::TagItem> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::AlterSchemaItem> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::EdgeItem> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::IndexItem> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::HostItem> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::UserItem> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::RoleItem> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::ExecResp> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::AdminJobReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::JobDesc> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::TaskDesc> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::AdminJobResult> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::AdminJobResp> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::Correlativity> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::StatsItem> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::CreateSpaceReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::CreateSpaceAsReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::DropSpaceReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::ListSpacesReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::ListSpacesResp> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::GetSpaceReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::GetSpaceResp> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::CreateTagReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::AlterTagReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::DropTagReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::ListTagsReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::ListTagsResp> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::GetTagReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::GetTagResp> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::CreateEdgeReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::AlterEdgeReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::GetEdgeReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::GetEdgeResp> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::DropEdgeReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::ListEdgesReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::ListEdgesResp> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::ListHostsReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::ListHostsResp> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::PartItem> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::ListPartsReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::ListPartsResp> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::GetPartsAllocReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::GetPartsAllocResp> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::MultiPutReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::GetReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::GetResp> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::MultiGetReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::MultiGetResp> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::RemoveReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::RemoveRangeReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::ScanReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::ScanResp> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::HBResp> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::LeaderInfo> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::HBReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::IndexFieldDef> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::CreateTagIndexReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::DropTagIndexReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::GetTagIndexReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::GetTagIndexResp> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::ListTagIndexesReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::ListTagIndexesResp> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::CreateEdgeIndexReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::DropEdgeIndexReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::GetEdgeIndexReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::GetEdgeIndexResp> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::ListEdgeIndexesReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::ListEdgeIndexesResp> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::RebuildIndexReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::CreateUserReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::DropUserReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::AlterUserReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::GrantRoleReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::RevokeRoleReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::ListUsersReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::ListUsersResp> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::ListRolesReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::ListRolesResp> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::GetUserRolesReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::ChangePasswordReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::BalanceReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::BalanceTask> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::BalanceResp> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::LeaderBalanceReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::ConfigItem> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::RegConfigReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::GetConfigReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::GetConfigResp> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::SetConfigReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::ListConfigsReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::ListConfigsResp> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::CreateSnapshotReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::DropSnapshotReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::ListSnapshotsReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::Snapshot> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::ListSnapshotsResp> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::ListIndexStatusReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::IndexStatus> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::ListIndexStatusResp> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::AddZoneReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::DropZoneReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::AddHostIntoZoneReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::DropHostFromZoneReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::GetZoneReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::GetZoneResp> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::ListZonesReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::Zone> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::ListZonesResp> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::AddGroupReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::DropGroupReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::AddZoneIntoGroupReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::DropZoneFromGroupReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::GetGroupReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::GetGroupResp> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::ListGroupsReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::Group> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::ListGroupsResp> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::AddListenerReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::RemoveListenerReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::ListListenerReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::ListenerInfo> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::ListListenerResp> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::GetStatsReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::GetStatsResp> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::BackupInfo> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::SpaceBackupInfo> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::BackupMeta> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::CreateBackupReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::CreateBackupResp> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::HostPair> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::RestoreMetaReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::FTClient> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::SignInFTServiceReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::SignOutFTServiceReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::ListFTClientsReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::ListFTClientsResp> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::FTIndex> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::CreateFTIndexReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::DropFTIndexReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::ListFTIndexesReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::ListFTIndexesResp> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::QueryDesc> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::Session> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::CreateSessionReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::CreateSessionResp> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::UpdateSessionsReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::UpdateSessionsResp> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::ListSessionsReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::ListSessionsResp> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::GetSessionReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::GetSessionResp> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::RemoveSessionReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::KillQueryReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::ReportTaskReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::ListClusterInfoResp> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::ListClusterInfoReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::GetMetaDirInfoResp> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::GetMetaDirInfoReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::VerifyClientVersionResp> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::meta::cpp2::VerifyClientVersionReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class ServiceMetadata<::nebula::meta::cpp2::MetaServiceSvIf> { + public: + static void gen(ThriftMetadata& metadata, ThriftServiceContext& context); + private: + static void gen_createSpace(ThriftMetadata& metadata, ThriftService& context); + static void gen_dropSpace(ThriftMetadata& metadata, ThriftService& context); + static void gen_getSpace(ThriftMetadata& metadata, ThriftService& context); + static void gen_listSpaces(ThriftMetadata& metadata, ThriftService& context); + static void gen_createSpaceAs(ThriftMetadata& metadata, ThriftService& context); + static void gen_createTag(ThriftMetadata& metadata, ThriftService& context); + static void gen_alterTag(ThriftMetadata& metadata, ThriftService& context); + static void gen_dropTag(ThriftMetadata& metadata, ThriftService& context); + static void gen_getTag(ThriftMetadata& metadata, ThriftService& context); + static void gen_listTags(ThriftMetadata& metadata, ThriftService& context); + static void gen_createEdge(ThriftMetadata& metadata, ThriftService& context); + static void gen_alterEdge(ThriftMetadata& metadata, ThriftService& context); + static void gen_dropEdge(ThriftMetadata& metadata, ThriftService& context); + static void gen_getEdge(ThriftMetadata& metadata, ThriftService& context); + static void gen_listEdges(ThriftMetadata& metadata, ThriftService& context); + static void gen_listHosts(ThriftMetadata& metadata, ThriftService& context); + static void gen_getPartsAlloc(ThriftMetadata& metadata, ThriftService& context); + static void gen_listParts(ThriftMetadata& metadata, ThriftService& context); + static void gen_multiPut(ThriftMetadata& metadata, ThriftService& context); + static void gen_get(ThriftMetadata& metadata, ThriftService& context); + static void gen_multiGet(ThriftMetadata& metadata, ThriftService& context); + static void gen_remove(ThriftMetadata& metadata, ThriftService& context); + static void gen_removeRange(ThriftMetadata& metadata, ThriftService& context); + static void gen_scan(ThriftMetadata& metadata, ThriftService& context); + static void gen_createTagIndex(ThriftMetadata& metadata, ThriftService& context); + static void gen_dropTagIndex(ThriftMetadata& metadata, ThriftService& context); + static void gen_getTagIndex(ThriftMetadata& metadata, ThriftService& context); + static void gen_listTagIndexes(ThriftMetadata& metadata, ThriftService& context); + static void gen_rebuildTagIndex(ThriftMetadata& metadata, ThriftService& context); + static void gen_listTagIndexStatus(ThriftMetadata& metadata, ThriftService& context); + static void gen_createEdgeIndex(ThriftMetadata& metadata, ThriftService& context); + static void gen_dropEdgeIndex(ThriftMetadata& metadata, ThriftService& context); + static void gen_getEdgeIndex(ThriftMetadata& metadata, ThriftService& context); + static void gen_listEdgeIndexes(ThriftMetadata& metadata, ThriftService& context); + static void gen_rebuildEdgeIndex(ThriftMetadata& metadata, ThriftService& context); + static void gen_listEdgeIndexStatus(ThriftMetadata& metadata, ThriftService& context); + static void gen_createUser(ThriftMetadata& metadata, ThriftService& context); + static void gen_dropUser(ThriftMetadata& metadata, ThriftService& context); + static void gen_alterUser(ThriftMetadata& metadata, ThriftService& context); + static void gen_grantRole(ThriftMetadata& metadata, ThriftService& context); + static void gen_revokeRole(ThriftMetadata& metadata, ThriftService& context); + static void gen_listUsers(ThriftMetadata& metadata, ThriftService& context); + static void gen_listRoles(ThriftMetadata& metadata, ThriftService& context); + static void gen_getUserRoles(ThriftMetadata& metadata, ThriftService& context); + static void gen_changePassword(ThriftMetadata& metadata, ThriftService& context); + static void gen_heartBeat(ThriftMetadata& metadata, ThriftService& context); + static void gen_balance(ThriftMetadata& metadata, ThriftService& context); + static void gen_leaderBalance(ThriftMetadata& metadata, ThriftService& context); + static void gen_regConfig(ThriftMetadata& metadata, ThriftService& context); + static void gen_getConfig(ThriftMetadata& metadata, ThriftService& context); + static void gen_setConfig(ThriftMetadata& metadata, ThriftService& context); + static void gen_listConfigs(ThriftMetadata& metadata, ThriftService& context); + static void gen_createSnapshot(ThriftMetadata& metadata, ThriftService& context); + static void gen_dropSnapshot(ThriftMetadata& metadata, ThriftService& context); + static void gen_listSnapshots(ThriftMetadata& metadata, ThriftService& context); + static void gen_runAdminJob(ThriftMetadata& metadata, ThriftService& context); + static void gen_addZone(ThriftMetadata& metadata, ThriftService& context); + static void gen_dropZone(ThriftMetadata& metadata, ThriftService& context); + static void gen_addHostIntoZone(ThriftMetadata& metadata, ThriftService& context); + static void gen_dropHostFromZone(ThriftMetadata& metadata, ThriftService& context); + static void gen_getZone(ThriftMetadata& metadata, ThriftService& context); + static void gen_listZones(ThriftMetadata& metadata, ThriftService& context); + static void gen_addGroup(ThriftMetadata& metadata, ThriftService& context); + static void gen_dropGroup(ThriftMetadata& metadata, ThriftService& context); + static void gen_addZoneIntoGroup(ThriftMetadata& metadata, ThriftService& context); + static void gen_dropZoneFromGroup(ThriftMetadata& metadata, ThriftService& context); + static void gen_getGroup(ThriftMetadata& metadata, ThriftService& context); + static void gen_listGroups(ThriftMetadata& metadata, ThriftService& context); + static void gen_createBackup(ThriftMetadata& metadata, ThriftService& context); + static void gen_restoreMeta(ThriftMetadata& metadata, ThriftService& context); + static void gen_addListener(ThriftMetadata& metadata, ThriftService& context); + static void gen_removeListener(ThriftMetadata& metadata, ThriftService& context); + static void gen_listListener(ThriftMetadata& metadata, ThriftService& context); + static void gen_getStats(ThriftMetadata& metadata, ThriftService& context); + static void gen_signInFTService(ThriftMetadata& metadata, ThriftService& context); + static void gen_signOutFTService(ThriftMetadata& metadata, ThriftService& context); + static void gen_listFTClients(ThriftMetadata& metadata, ThriftService& context); + static void gen_createFTIndex(ThriftMetadata& metadata, ThriftService& context); + static void gen_dropFTIndex(ThriftMetadata& metadata, ThriftService& context); + static void gen_listFTIndexes(ThriftMetadata& metadata, ThriftService& context); + static void gen_createSession(ThriftMetadata& metadata, ThriftService& context); + static void gen_updateSessions(ThriftMetadata& metadata, ThriftService& context); + static void gen_listSessions(ThriftMetadata& metadata, ThriftService& context); + static void gen_getSession(ThriftMetadata& metadata, ThriftService& context); + static void gen_removeSession(ThriftMetadata& metadata, ThriftService& context); + static void gen_killQuery(ThriftMetadata& metadata, ThriftService& context); + static void gen_reportTaskFinish(ThriftMetadata& metadata, ThriftService& context); + static void gen_listCluster(ThriftMetadata& metadata, ThriftService& context); + static void gen_getMetaDirInfo(ThriftMetadata& metadata, ThriftService& context); + static void gen_verifyClientVersion(ThriftMetadata& metadata, ThriftService& context); +}; +} // namespace md +} // namespace detail +} // namespace thrift +} // namespace apache diff --git a/src/interface/gen-cpp2/meta_types.cpp b/src/interface/gen-cpp2/meta_types.cpp new file mode 100644 index 00000000..3e02e894 --- /dev/null +++ b/src/interface/gen-cpp2/meta_types.cpp @@ -0,0 +1,19319 @@ +/** + * Autogenerated by Thrift for meta.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#include "meta_types.h" +#include "meta_types.tcc" + +#include + +#include "meta_data.h" + + +namespace apache { namespace thrift { + +constexpr std::size_t const TEnumTraits<::nebula::meta::cpp2::AlterSchemaOp>::size; +folly::Range<::nebula::meta::cpp2::AlterSchemaOp const*> const TEnumTraits<::nebula::meta::cpp2::AlterSchemaOp>::values = folly::range(TEnumDataStorage<::nebula::meta::cpp2::AlterSchemaOp>::values); +folly::Range const TEnumTraits<::nebula::meta::cpp2::AlterSchemaOp>::names = folly::range(TEnumDataStorage<::nebula::meta::cpp2::AlterSchemaOp>::names); + +char const* TEnumTraits<::nebula::meta::cpp2::AlterSchemaOp>::findName(type value) { + using factory = ::nebula::meta::cpp2::_AlterSchemaOp_EnumMapFactory; + static folly::Indestructible const map{ + factory::makeValuesToNamesMap()}; + auto found = map->find(value); + return found == map->end() ? nullptr : found->second; +} + +bool TEnumTraits<::nebula::meta::cpp2::AlterSchemaOp>::findValue(char const* name, type* out) { + using factory = ::nebula::meta::cpp2::_AlterSchemaOp_EnumMapFactory; + static folly::Indestructible const map{ + factory::makeNamesToValuesMap()}; + auto found = map->find(name); + return found == map->end() ? false : (*out = found->second, true); +} + +}} // apache::thrift + +namespace nebula { namespace meta { namespace cpp2 { +FOLLY_PUSH_WARNING +FOLLY_GNU_DISABLE_WARNING("-Wdeprecated-declarations") +const _AlterSchemaOp_EnumMapFactory::ValuesToNamesMapType _AlterSchemaOp_VALUES_TO_NAMES = _AlterSchemaOp_EnumMapFactory::makeValuesToNamesMap(); +const _AlterSchemaOp_EnumMapFactory::NamesToValuesMapType _AlterSchemaOp_NAMES_TO_VALUES = _AlterSchemaOp_EnumMapFactory::makeNamesToValuesMap(); +FOLLY_POP_WARNING + +}}} // nebula::meta::cpp2 + +namespace apache { namespace thrift { + +constexpr std::size_t const TEnumTraits<::nebula::meta::cpp2::RoleType>::size; +folly::Range<::nebula::meta::cpp2::RoleType const*> const TEnumTraits<::nebula::meta::cpp2::RoleType>::values = folly::range(TEnumDataStorage<::nebula::meta::cpp2::RoleType>::values); +folly::Range const TEnumTraits<::nebula::meta::cpp2::RoleType>::names = folly::range(TEnumDataStorage<::nebula::meta::cpp2::RoleType>::names); + +char const* TEnumTraits<::nebula::meta::cpp2::RoleType>::findName(type value) { + using factory = ::nebula::meta::cpp2::_RoleType_EnumMapFactory; + static folly::Indestructible const map{ + factory::makeValuesToNamesMap()}; + auto found = map->find(value); + return found == map->end() ? nullptr : found->second; +} + +bool TEnumTraits<::nebula::meta::cpp2::RoleType>::findValue(char const* name, type* out) { + using factory = ::nebula::meta::cpp2::_RoleType_EnumMapFactory; + static folly::Indestructible const map{ + factory::makeNamesToValuesMap()}; + auto found = map->find(name); + return found == map->end() ? false : (*out = found->second, true); +} + +}} // apache::thrift + +namespace nebula { namespace meta { namespace cpp2 { +FOLLY_PUSH_WARNING +FOLLY_GNU_DISABLE_WARNING("-Wdeprecated-declarations") +const _RoleType_EnumMapFactory::ValuesToNamesMapType _RoleType_VALUES_TO_NAMES = _RoleType_EnumMapFactory::makeValuesToNamesMap(); +const _RoleType_EnumMapFactory::NamesToValuesMapType _RoleType_NAMES_TO_VALUES = _RoleType_EnumMapFactory::makeNamesToValuesMap(); +FOLLY_POP_WARNING + +}}} // nebula::meta::cpp2 + +namespace apache { namespace thrift { + +constexpr std::size_t const TEnumTraits<::nebula::meta::cpp2::GeoShape>::size; +folly::Range<::nebula::meta::cpp2::GeoShape const*> const TEnumTraits<::nebula::meta::cpp2::GeoShape>::values = folly::range(TEnumDataStorage<::nebula::meta::cpp2::GeoShape>::values); +folly::Range const TEnumTraits<::nebula::meta::cpp2::GeoShape>::names = folly::range(TEnumDataStorage<::nebula::meta::cpp2::GeoShape>::names); + +char const* TEnumTraits<::nebula::meta::cpp2::GeoShape>::findName(type value) { + using factory = ::nebula::meta::cpp2::_GeoShape_EnumMapFactory; + static folly::Indestructible const map{ + factory::makeValuesToNamesMap()}; + auto found = map->find(value); + return found == map->end() ? nullptr : found->second; +} + +bool TEnumTraits<::nebula::meta::cpp2::GeoShape>::findValue(char const* name, type* out) { + using factory = ::nebula::meta::cpp2::_GeoShape_EnumMapFactory; + static folly::Indestructible const map{ + factory::makeNamesToValuesMap()}; + auto found = map->find(name); + return found == map->end() ? false : (*out = found->second, true); +} + +}} // apache::thrift + +namespace nebula { namespace meta { namespace cpp2 { +FOLLY_PUSH_WARNING +FOLLY_GNU_DISABLE_WARNING("-Wdeprecated-declarations") +const _GeoShape_EnumMapFactory::ValuesToNamesMapType _GeoShape_VALUES_TO_NAMES = _GeoShape_EnumMapFactory::makeValuesToNamesMap(); +const _GeoShape_EnumMapFactory::NamesToValuesMapType _GeoShape_NAMES_TO_VALUES = _GeoShape_EnumMapFactory::makeNamesToValuesMap(); +FOLLY_POP_WARNING + +}}} // nebula::meta::cpp2 + +namespace apache { namespace thrift { + +constexpr std::size_t const TEnumTraits<::nebula::meta::cpp2::PropertyType>::size; +folly::Range<::nebula::meta::cpp2::PropertyType const*> const TEnumTraits<::nebula::meta::cpp2::PropertyType>::values = folly::range(TEnumDataStorage<::nebula::meta::cpp2::PropertyType>::values); +folly::Range const TEnumTraits<::nebula::meta::cpp2::PropertyType>::names = folly::range(TEnumDataStorage<::nebula::meta::cpp2::PropertyType>::names); + +char const* TEnumTraits<::nebula::meta::cpp2::PropertyType>::findName(type value) { + using factory = ::nebula::meta::cpp2::_PropertyType_EnumMapFactory; + static folly::Indestructible const map{ + factory::makeValuesToNamesMap()}; + auto found = map->find(value); + return found == map->end() ? nullptr : found->second; +} + +bool TEnumTraits<::nebula::meta::cpp2::PropertyType>::findValue(char const* name, type* out) { + using factory = ::nebula::meta::cpp2::_PropertyType_EnumMapFactory; + static folly::Indestructible const map{ + factory::makeNamesToValuesMap()}; + auto found = map->find(name); + return found == map->end() ? false : (*out = found->second, true); +} + +}} // apache::thrift + +namespace nebula { namespace meta { namespace cpp2 { +FOLLY_PUSH_WARNING +FOLLY_GNU_DISABLE_WARNING("-Wdeprecated-declarations") +const _PropertyType_EnumMapFactory::ValuesToNamesMapType _PropertyType_VALUES_TO_NAMES = _PropertyType_EnumMapFactory::makeValuesToNamesMap(); +const _PropertyType_EnumMapFactory::NamesToValuesMapType _PropertyType_NAMES_TO_VALUES = _PropertyType_EnumMapFactory::makeNamesToValuesMap(); +FOLLY_POP_WARNING + +}}} // nebula::meta::cpp2 + +namespace apache { namespace thrift { + +constexpr std::size_t const TEnumTraits<::nebula::meta::cpp2::IsolationLevel>::size; +folly::Range<::nebula::meta::cpp2::IsolationLevel const*> const TEnumTraits<::nebula::meta::cpp2::IsolationLevel>::values = folly::range(TEnumDataStorage<::nebula::meta::cpp2::IsolationLevel>::values); +folly::Range const TEnumTraits<::nebula::meta::cpp2::IsolationLevel>::names = folly::range(TEnumDataStorage<::nebula::meta::cpp2::IsolationLevel>::names); + +char const* TEnumTraits<::nebula::meta::cpp2::IsolationLevel>::findName(type value) { + using factory = ::nebula::meta::cpp2::_IsolationLevel_EnumMapFactory; + static folly::Indestructible const map{ + factory::makeValuesToNamesMap()}; + auto found = map->find(value); + return found == map->end() ? nullptr : found->second; +} + +bool TEnumTraits<::nebula::meta::cpp2::IsolationLevel>::findValue(char const* name, type* out) { + using factory = ::nebula::meta::cpp2::_IsolationLevel_EnumMapFactory; + static folly::Indestructible const map{ + factory::makeNamesToValuesMap()}; + auto found = map->find(name); + return found == map->end() ? false : (*out = found->second, true); +} + +}} // apache::thrift + +namespace nebula { namespace meta { namespace cpp2 { +FOLLY_PUSH_WARNING +FOLLY_GNU_DISABLE_WARNING("-Wdeprecated-declarations") +const _IsolationLevel_EnumMapFactory::ValuesToNamesMapType _IsolationLevel_VALUES_TO_NAMES = _IsolationLevel_EnumMapFactory::makeValuesToNamesMap(); +const _IsolationLevel_EnumMapFactory::NamesToValuesMapType _IsolationLevel_NAMES_TO_VALUES = _IsolationLevel_EnumMapFactory::makeNamesToValuesMap(); +FOLLY_POP_WARNING + +}}} // nebula::meta::cpp2 + +namespace apache { namespace thrift { + +constexpr std::size_t const TEnumTraits<::nebula::meta::cpp2::HostStatus>::size; +folly::Range<::nebula::meta::cpp2::HostStatus const*> const TEnumTraits<::nebula::meta::cpp2::HostStatus>::values = folly::range(TEnumDataStorage<::nebula::meta::cpp2::HostStatus>::values); +folly::Range const TEnumTraits<::nebula::meta::cpp2::HostStatus>::names = folly::range(TEnumDataStorage<::nebula::meta::cpp2::HostStatus>::names); + +char const* TEnumTraits<::nebula::meta::cpp2::HostStatus>::findName(type value) { + using factory = ::nebula::meta::cpp2::_HostStatus_EnumMapFactory; + static folly::Indestructible const map{ + factory::makeValuesToNamesMap()}; + auto found = map->find(value); + return found == map->end() ? nullptr : found->second; +} + +bool TEnumTraits<::nebula::meta::cpp2::HostStatus>::findValue(char const* name, type* out) { + using factory = ::nebula::meta::cpp2::_HostStatus_EnumMapFactory; + static folly::Indestructible const map{ + factory::makeNamesToValuesMap()}; + auto found = map->find(name); + return found == map->end() ? false : (*out = found->second, true); +} + +}} // apache::thrift + +namespace nebula { namespace meta { namespace cpp2 { +FOLLY_PUSH_WARNING +FOLLY_GNU_DISABLE_WARNING("-Wdeprecated-declarations") +const _HostStatus_EnumMapFactory::ValuesToNamesMapType _HostStatus_VALUES_TO_NAMES = _HostStatus_EnumMapFactory::makeValuesToNamesMap(); +const _HostStatus_EnumMapFactory::NamesToValuesMapType _HostStatus_NAMES_TO_VALUES = _HostStatus_EnumMapFactory::makeNamesToValuesMap(); +FOLLY_POP_WARNING + +}}} // nebula::meta::cpp2 + +namespace apache { namespace thrift { + +constexpr std::size_t const TEnumTraits<::nebula::meta::cpp2::SnapshotStatus>::size; +folly::Range<::nebula::meta::cpp2::SnapshotStatus const*> const TEnumTraits<::nebula::meta::cpp2::SnapshotStatus>::values = folly::range(TEnumDataStorage<::nebula::meta::cpp2::SnapshotStatus>::values); +folly::Range const TEnumTraits<::nebula::meta::cpp2::SnapshotStatus>::names = folly::range(TEnumDataStorage<::nebula::meta::cpp2::SnapshotStatus>::names); + +char const* TEnumTraits<::nebula::meta::cpp2::SnapshotStatus>::findName(type value) { + using factory = ::nebula::meta::cpp2::_SnapshotStatus_EnumMapFactory; + static folly::Indestructible const map{ + factory::makeValuesToNamesMap()}; + auto found = map->find(value); + return found == map->end() ? nullptr : found->second; +} + +bool TEnumTraits<::nebula::meta::cpp2::SnapshotStatus>::findValue(char const* name, type* out) { + using factory = ::nebula::meta::cpp2::_SnapshotStatus_EnumMapFactory; + static folly::Indestructible const map{ + factory::makeNamesToValuesMap()}; + auto found = map->find(name); + return found == map->end() ? false : (*out = found->second, true); +} + +}} // apache::thrift + +namespace nebula { namespace meta { namespace cpp2 { +FOLLY_PUSH_WARNING +FOLLY_GNU_DISABLE_WARNING("-Wdeprecated-declarations") +const _SnapshotStatus_EnumMapFactory::ValuesToNamesMapType _SnapshotStatus_VALUES_TO_NAMES = _SnapshotStatus_EnumMapFactory::makeValuesToNamesMap(); +const _SnapshotStatus_EnumMapFactory::NamesToValuesMapType _SnapshotStatus_NAMES_TO_VALUES = _SnapshotStatus_EnumMapFactory::makeNamesToValuesMap(); +FOLLY_POP_WARNING + +}}} // nebula::meta::cpp2 + +namespace apache { namespace thrift { + +constexpr std::size_t const TEnumTraits<::nebula::meta::cpp2::AdminJobOp>::size; +folly::Range<::nebula::meta::cpp2::AdminJobOp const*> const TEnumTraits<::nebula::meta::cpp2::AdminJobOp>::values = folly::range(TEnumDataStorage<::nebula::meta::cpp2::AdminJobOp>::values); +folly::Range const TEnumTraits<::nebula::meta::cpp2::AdminJobOp>::names = folly::range(TEnumDataStorage<::nebula::meta::cpp2::AdminJobOp>::names); + +char const* TEnumTraits<::nebula::meta::cpp2::AdminJobOp>::findName(type value) { + using factory = ::nebula::meta::cpp2::_AdminJobOp_EnumMapFactory; + static folly::Indestructible const map{ + factory::makeValuesToNamesMap()}; + auto found = map->find(value); + return found == map->end() ? nullptr : found->second; +} + +bool TEnumTraits<::nebula::meta::cpp2::AdminJobOp>::findValue(char const* name, type* out) { + using factory = ::nebula::meta::cpp2::_AdminJobOp_EnumMapFactory; + static folly::Indestructible const map{ + factory::makeNamesToValuesMap()}; + auto found = map->find(name); + return found == map->end() ? false : (*out = found->second, true); +} + +}} // apache::thrift + +namespace nebula { namespace meta { namespace cpp2 { +FOLLY_PUSH_WARNING +FOLLY_GNU_DISABLE_WARNING("-Wdeprecated-declarations") +const _AdminJobOp_EnumMapFactory::ValuesToNamesMapType _AdminJobOp_VALUES_TO_NAMES = _AdminJobOp_EnumMapFactory::makeValuesToNamesMap(); +const _AdminJobOp_EnumMapFactory::NamesToValuesMapType _AdminJobOp_NAMES_TO_VALUES = _AdminJobOp_EnumMapFactory::makeNamesToValuesMap(); +FOLLY_POP_WARNING + +}}} // nebula::meta::cpp2 + +namespace apache { namespace thrift { + +constexpr std::size_t const TEnumTraits<::nebula::meta::cpp2::AdminCmd>::size; +folly::Range<::nebula::meta::cpp2::AdminCmd const*> const TEnumTraits<::nebula::meta::cpp2::AdminCmd>::values = folly::range(TEnumDataStorage<::nebula::meta::cpp2::AdminCmd>::values); +folly::Range const TEnumTraits<::nebula::meta::cpp2::AdminCmd>::names = folly::range(TEnumDataStorage<::nebula::meta::cpp2::AdminCmd>::names); + +char const* TEnumTraits<::nebula::meta::cpp2::AdminCmd>::findName(type value) { + using factory = ::nebula::meta::cpp2::_AdminCmd_EnumMapFactory; + static folly::Indestructible const map{ + factory::makeValuesToNamesMap()}; + auto found = map->find(value); + return found == map->end() ? nullptr : found->second; +} + +bool TEnumTraits<::nebula::meta::cpp2::AdminCmd>::findValue(char const* name, type* out) { + using factory = ::nebula::meta::cpp2::_AdminCmd_EnumMapFactory; + static folly::Indestructible const map{ + factory::makeNamesToValuesMap()}; + auto found = map->find(name); + return found == map->end() ? false : (*out = found->second, true); +} + +}} // apache::thrift + +namespace nebula { namespace meta { namespace cpp2 { +FOLLY_PUSH_WARNING +FOLLY_GNU_DISABLE_WARNING("-Wdeprecated-declarations") +const _AdminCmd_EnumMapFactory::ValuesToNamesMapType _AdminCmd_VALUES_TO_NAMES = _AdminCmd_EnumMapFactory::makeValuesToNamesMap(); +const _AdminCmd_EnumMapFactory::NamesToValuesMapType _AdminCmd_NAMES_TO_VALUES = _AdminCmd_EnumMapFactory::makeNamesToValuesMap(); +FOLLY_POP_WARNING + +}}} // nebula::meta::cpp2 + +namespace apache { namespace thrift { + +constexpr std::size_t const TEnumTraits<::nebula::meta::cpp2::JobStatus>::size; +folly::Range<::nebula::meta::cpp2::JobStatus const*> const TEnumTraits<::nebula::meta::cpp2::JobStatus>::values = folly::range(TEnumDataStorage<::nebula::meta::cpp2::JobStatus>::values); +folly::Range const TEnumTraits<::nebula::meta::cpp2::JobStatus>::names = folly::range(TEnumDataStorage<::nebula::meta::cpp2::JobStatus>::names); + +char const* TEnumTraits<::nebula::meta::cpp2::JobStatus>::findName(type value) { + using factory = ::nebula::meta::cpp2::_JobStatus_EnumMapFactory; + static folly::Indestructible const map{ + factory::makeValuesToNamesMap()}; + auto found = map->find(value); + return found == map->end() ? nullptr : found->second; +} + +bool TEnumTraits<::nebula::meta::cpp2::JobStatus>::findValue(char const* name, type* out) { + using factory = ::nebula::meta::cpp2::_JobStatus_EnumMapFactory; + static folly::Indestructible const map{ + factory::makeNamesToValuesMap()}; + auto found = map->find(name); + return found == map->end() ? false : (*out = found->second, true); +} + +}} // apache::thrift + +namespace nebula { namespace meta { namespace cpp2 { +FOLLY_PUSH_WARNING +FOLLY_GNU_DISABLE_WARNING("-Wdeprecated-declarations") +const _JobStatus_EnumMapFactory::ValuesToNamesMapType _JobStatus_VALUES_TO_NAMES = _JobStatus_EnumMapFactory::makeValuesToNamesMap(); +const _JobStatus_EnumMapFactory::NamesToValuesMapType _JobStatus_NAMES_TO_VALUES = _JobStatus_EnumMapFactory::makeNamesToValuesMap(); +FOLLY_POP_WARNING + +}}} // nebula::meta::cpp2 + +namespace apache { namespace thrift { + +constexpr std::size_t const TEnumTraits<::nebula::meta::cpp2::ListHostType>::size; +folly::Range<::nebula::meta::cpp2::ListHostType const*> const TEnumTraits<::nebula::meta::cpp2::ListHostType>::values = folly::range(TEnumDataStorage<::nebula::meta::cpp2::ListHostType>::values); +folly::Range const TEnumTraits<::nebula::meta::cpp2::ListHostType>::names = folly::range(TEnumDataStorage<::nebula::meta::cpp2::ListHostType>::names); + +char const* TEnumTraits<::nebula::meta::cpp2::ListHostType>::findName(type value) { + using factory = ::nebula::meta::cpp2::_ListHostType_EnumMapFactory; + static folly::Indestructible const map{ + factory::makeValuesToNamesMap()}; + auto found = map->find(value); + return found == map->end() ? nullptr : found->second; +} + +bool TEnumTraits<::nebula::meta::cpp2::ListHostType>::findValue(char const* name, type* out) { + using factory = ::nebula::meta::cpp2::_ListHostType_EnumMapFactory; + static folly::Indestructible const map{ + factory::makeNamesToValuesMap()}; + auto found = map->find(name); + return found == map->end() ? false : (*out = found->second, true); +} + +}} // apache::thrift + +namespace nebula { namespace meta { namespace cpp2 { +FOLLY_PUSH_WARNING +FOLLY_GNU_DISABLE_WARNING("-Wdeprecated-declarations") +const _ListHostType_EnumMapFactory::ValuesToNamesMapType _ListHostType_VALUES_TO_NAMES = _ListHostType_EnumMapFactory::makeValuesToNamesMap(); +const _ListHostType_EnumMapFactory::NamesToValuesMapType _ListHostType_NAMES_TO_VALUES = _ListHostType_EnumMapFactory::makeNamesToValuesMap(); +FOLLY_POP_WARNING + +}}} // nebula::meta::cpp2 + +namespace apache { namespace thrift { + +constexpr std::size_t const TEnumTraits<::nebula::meta::cpp2::HostRole>::size; +folly::Range<::nebula::meta::cpp2::HostRole const*> const TEnumTraits<::nebula::meta::cpp2::HostRole>::values = folly::range(TEnumDataStorage<::nebula::meta::cpp2::HostRole>::values); +folly::Range const TEnumTraits<::nebula::meta::cpp2::HostRole>::names = folly::range(TEnumDataStorage<::nebula::meta::cpp2::HostRole>::names); + +char const* TEnumTraits<::nebula::meta::cpp2::HostRole>::findName(type value) { + using factory = ::nebula::meta::cpp2::_HostRole_EnumMapFactory; + static folly::Indestructible const map{ + factory::makeValuesToNamesMap()}; + auto found = map->find(value); + return found == map->end() ? nullptr : found->second; +} + +bool TEnumTraits<::nebula::meta::cpp2::HostRole>::findValue(char const* name, type* out) { + using factory = ::nebula::meta::cpp2::_HostRole_EnumMapFactory; + static folly::Indestructible const map{ + factory::makeNamesToValuesMap()}; + auto found = map->find(name); + return found == map->end() ? false : (*out = found->second, true); +} + +}} // apache::thrift + +namespace nebula { namespace meta { namespace cpp2 { +FOLLY_PUSH_WARNING +FOLLY_GNU_DISABLE_WARNING("-Wdeprecated-declarations") +const _HostRole_EnumMapFactory::ValuesToNamesMapType _HostRole_VALUES_TO_NAMES = _HostRole_EnumMapFactory::makeValuesToNamesMap(); +const _HostRole_EnumMapFactory::NamesToValuesMapType _HostRole_NAMES_TO_VALUES = _HostRole_EnumMapFactory::makeNamesToValuesMap(); +FOLLY_POP_WARNING + +}}} // nebula::meta::cpp2 + +namespace apache { namespace thrift { + +constexpr std::size_t const TEnumTraits<::nebula::meta::cpp2::TaskResult>::size; +folly::Range<::nebula::meta::cpp2::TaskResult const*> const TEnumTraits<::nebula::meta::cpp2::TaskResult>::values = folly::range(TEnumDataStorage<::nebula::meta::cpp2::TaskResult>::values); +folly::Range const TEnumTraits<::nebula::meta::cpp2::TaskResult>::names = folly::range(TEnumDataStorage<::nebula::meta::cpp2::TaskResult>::names); + +char const* TEnumTraits<::nebula::meta::cpp2::TaskResult>::findName(type value) { + using factory = ::nebula::meta::cpp2::_TaskResult_EnumMapFactory; + static folly::Indestructible const map{ + factory::makeValuesToNamesMap()}; + auto found = map->find(value); + return found == map->end() ? nullptr : found->second; +} + +bool TEnumTraits<::nebula::meta::cpp2::TaskResult>::findValue(char const* name, type* out) { + using factory = ::nebula::meta::cpp2::_TaskResult_EnumMapFactory; + static folly::Indestructible const map{ + factory::makeNamesToValuesMap()}; + auto found = map->find(name); + return found == map->end() ? false : (*out = found->second, true); +} + +}} // apache::thrift + +namespace nebula { namespace meta { namespace cpp2 { +FOLLY_PUSH_WARNING +FOLLY_GNU_DISABLE_WARNING("-Wdeprecated-declarations") +const _TaskResult_EnumMapFactory::ValuesToNamesMapType _TaskResult_VALUES_TO_NAMES = _TaskResult_EnumMapFactory::makeValuesToNamesMap(); +const _TaskResult_EnumMapFactory::NamesToValuesMapType _TaskResult_NAMES_TO_VALUES = _TaskResult_EnumMapFactory::makeNamesToValuesMap(); +FOLLY_POP_WARNING + +}}} // nebula::meta::cpp2 + +namespace apache { namespace thrift { + +constexpr std::size_t const TEnumTraits<::nebula::meta::cpp2::ConfigModule>::size; +folly::Range<::nebula::meta::cpp2::ConfigModule const*> const TEnumTraits<::nebula::meta::cpp2::ConfigModule>::values = folly::range(TEnumDataStorage<::nebula::meta::cpp2::ConfigModule>::values); +folly::Range const TEnumTraits<::nebula::meta::cpp2::ConfigModule>::names = folly::range(TEnumDataStorage<::nebula::meta::cpp2::ConfigModule>::names); + +char const* TEnumTraits<::nebula::meta::cpp2::ConfigModule>::findName(type value) { + using factory = ::nebula::meta::cpp2::_ConfigModule_EnumMapFactory; + static folly::Indestructible const map{ + factory::makeValuesToNamesMap()}; + auto found = map->find(value); + return found == map->end() ? nullptr : found->second; +} + +bool TEnumTraits<::nebula::meta::cpp2::ConfigModule>::findValue(char const* name, type* out) { + using factory = ::nebula::meta::cpp2::_ConfigModule_EnumMapFactory; + static folly::Indestructible const map{ + factory::makeNamesToValuesMap()}; + auto found = map->find(name); + return found == map->end() ? false : (*out = found->second, true); +} + +}} // apache::thrift + +namespace nebula { namespace meta { namespace cpp2 { +FOLLY_PUSH_WARNING +FOLLY_GNU_DISABLE_WARNING("-Wdeprecated-declarations") +const _ConfigModule_EnumMapFactory::ValuesToNamesMapType _ConfigModule_VALUES_TO_NAMES = _ConfigModule_EnumMapFactory::makeValuesToNamesMap(); +const _ConfigModule_EnumMapFactory::NamesToValuesMapType _ConfigModule_NAMES_TO_VALUES = _ConfigModule_EnumMapFactory::makeNamesToValuesMap(); +FOLLY_POP_WARNING + +}}} // nebula::meta::cpp2 + +namespace apache { namespace thrift { + +constexpr std::size_t const TEnumTraits<::nebula::meta::cpp2::ConfigMode>::size; +folly::Range<::nebula::meta::cpp2::ConfigMode const*> const TEnumTraits<::nebula::meta::cpp2::ConfigMode>::values = folly::range(TEnumDataStorage<::nebula::meta::cpp2::ConfigMode>::values); +folly::Range const TEnumTraits<::nebula::meta::cpp2::ConfigMode>::names = folly::range(TEnumDataStorage<::nebula::meta::cpp2::ConfigMode>::names); + +char const* TEnumTraits<::nebula::meta::cpp2::ConfigMode>::findName(type value) { + using factory = ::nebula::meta::cpp2::_ConfigMode_EnumMapFactory; + static folly::Indestructible const map{ + factory::makeValuesToNamesMap()}; + auto found = map->find(value); + return found == map->end() ? nullptr : found->second; +} + +bool TEnumTraits<::nebula::meta::cpp2::ConfigMode>::findValue(char const* name, type* out) { + using factory = ::nebula::meta::cpp2::_ConfigMode_EnumMapFactory; + static folly::Indestructible const map{ + factory::makeNamesToValuesMap()}; + auto found = map->find(name); + return found == map->end() ? false : (*out = found->second, true); +} + +}} // apache::thrift + +namespace nebula { namespace meta { namespace cpp2 { +FOLLY_PUSH_WARNING +FOLLY_GNU_DISABLE_WARNING("-Wdeprecated-declarations") +const _ConfigMode_EnumMapFactory::ValuesToNamesMapType _ConfigMode_VALUES_TO_NAMES = _ConfigMode_EnumMapFactory::makeValuesToNamesMap(); +const _ConfigMode_EnumMapFactory::NamesToValuesMapType _ConfigMode_NAMES_TO_VALUES = _ConfigMode_EnumMapFactory::makeNamesToValuesMap(); +FOLLY_POP_WARNING + +}}} // nebula::meta::cpp2 + +namespace apache { namespace thrift { + +constexpr std::size_t const TEnumTraits<::nebula::meta::cpp2::ListenerType>::size; +folly::Range<::nebula::meta::cpp2::ListenerType const*> const TEnumTraits<::nebula::meta::cpp2::ListenerType>::values = folly::range(TEnumDataStorage<::nebula::meta::cpp2::ListenerType>::values); +folly::Range const TEnumTraits<::nebula::meta::cpp2::ListenerType>::names = folly::range(TEnumDataStorage<::nebula::meta::cpp2::ListenerType>::names); + +char const* TEnumTraits<::nebula::meta::cpp2::ListenerType>::findName(type value) { + using factory = ::nebula::meta::cpp2::_ListenerType_EnumMapFactory; + static folly::Indestructible const map{ + factory::makeValuesToNamesMap()}; + auto found = map->find(value); + return found == map->end() ? nullptr : found->second; +} + +bool TEnumTraits<::nebula::meta::cpp2::ListenerType>::findValue(char const* name, type* out) { + using factory = ::nebula::meta::cpp2::_ListenerType_EnumMapFactory; + static folly::Indestructible const map{ + factory::makeNamesToValuesMap()}; + auto found = map->find(name); + return found == map->end() ? false : (*out = found->second, true); +} + +}} // apache::thrift + +namespace nebula { namespace meta { namespace cpp2 { +FOLLY_PUSH_WARNING +FOLLY_GNU_DISABLE_WARNING("-Wdeprecated-declarations") +const _ListenerType_EnumMapFactory::ValuesToNamesMapType _ListenerType_VALUES_TO_NAMES = _ListenerType_EnumMapFactory::makeValuesToNamesMap(); +const _ListenerType_EnumMapFactory::NamesToValuesMapType _ListenerType_NAMES_TO_VALUES = _ListenerType_EnumMapFactory::makeNamesToValuesMap(); +FOLLY_POP_WARNING + +}}} // nebula::meta::cpp2 + +namespace apache { namespace thrift { + +constexpr std::size_t const TEnumTraits<::nebula::meta::cpp2::FTServiceType>::size; +folly::Range<::nebula::meta::cpp2::FTServiceType const*> const TEnumTraits<::nebula::meta::cpp2::FTServiceType>::values = folly::range(TEnumDataStorage<::nebula::meta::cpp2::FTServiceType>::values); +folly::Range const TEnumTraits<::nebula::meta::cpp2::FTServiceType>::names = folly::range(TEnumDataStorage<::nebula::meta::cpp2::FTServiceType>::names); + +char const* TEnumTraits<::nebula::meta::cpp2::FTServiceType>::findName(type value) { + using factory = ::nebula::meta::cpp2::_FTServiceType_EnumMapFactory; + static folly::Indestructible const map{ + factory::makeValuesToNamesMap()}; + auto found = map->find(value); + return found == map->end() ? nullptr : found->second; +} + +bool TEnumTraits<::nebula::meta::cpp2::FTServiceType>::findValue(char const* name, type* out) { + using factory = ::nebula::meta::cpp2::_FTServiceType_EnumMapFactory; + static folly::Indestructible const map{ + factory::makeNamesToValuesMap()}; + auto found = map->find(name); + return found == map->end() ? false : (*out = found->second, true); +} + +}} // apache::thrift + +namespace nebula { namespace meta { namespace cpp2 { +FOLLY_PUSH_WARNING +FOLLY_GNU_DISABLE_WARNING("-Wdeprecated-declarations") +const _FTServiceType_EnumMapFactory::ValuesToNamesMapType _FTServiceType_VALUES_TO_NAMES = _FTServiceType_EnumMapFactory::makeValuesToNamesMap(); +const _FTServiceType_EnumMapFactory::NamesToValuesMapType _FTServiceType_NAMES_TO_VALUES = _FTServiceType_EnumMapFactory::makeNamesToValuesMap(); +FOLLY_POP_WARNING + +}}} // nebula::meta::cpp2 + +namespace apache { namespace thrift { + +constexpr std::size_t const TEnumTraits<::nebula::meta::cpp2::QueryStatus>::size; +folly::Range<::nebula::meta::cpp2::QueryStatus const*> const TEnumTraits<::nebula::meta::cpp2::QueryStatus>::values = folly::range(TEnumDataStorage<::nebula::meta::cpp2::QueryStatus>::values); +folly::Range const TEnumTraits<::nebula::meta::cpp2::QueryStatus>::names = folly::range(TEnumDataStorage<::nebula::meta::cpp2::QueryStatus>::names); + +char const* TEnumTraits<::nebula::meta::cpp2::QueryStatus>::findName(type value) { + using factory = ::nebula::meta::cpp2::_QueryStatus_EnumMapFactory; + static folly::Indestructible const map{ + factory::makeValuesToNamesMap()}; + auto found = map->find(value); + return found == map->end() ? nullptr : found->second; +} + +bool TEnumTraits<::nebula::meta::cpp2::QueryStatus>::findValue(char const* name, type* out) { + using factory = ::nebula::meta::cpp2::_QueryStatus_EnumMapFactory; + static folly::Indestructible const map{ + factory::makeNamesToValuesMap()}; + auto found = map->find(name); + return found == map->end() ? false : (*out = found->second, true); +} + +}} // apache::thrift + +namespace nebula { namespace meta { namespace cpp2 { +FOLLY_PUSH_WARNING +FOLLY_GNU_DISABLE_WARNING("-Wdeprecated-declarations") +const _QueryStatus_EnumMapFactory::ValuesToNamesMapType _QueryStatus_VALUES_TO_NAMES = _QueryStatus_EnumMapFactory::makeValuesToNamesMap(); +const _QueryStatus_EnumMapFactory::NamesToValuesMapType _QueryStatus_NAMES_TO_VALUES = _QueryStatus_EnumMapFactory::makeNamesToValuesMap(); +FOLLY_POP_WARNING + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::ID>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::ID>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace apache { namespace thrift { + +constexpr std::size_t const TEnumTraits<::nebula::meta::cpp2::ID::Type>::size; +folly::Range<::nebula::meta::cpp2::ID::Type const*> const TEnumTraits<::nebula::meta::cpp2::ID::Type>::values = folly::range(TEnumDataStorage<::nebula::meta::cpp2::ID::Type>::values); +folly::Range const TEnumTraits<::nebula::meta::cpp2::ID::Type>::names = folly::range(TEnumDataStorage<::nebula::meta::cpp2::ID::Type>::names); + +char const* TEnumTraits<::nebula::meta::cpp2::ID::Type>::findName(type value) { + using factory = detail::TEnumMapFactory<::nebula::meta::cpp2::ID::Type>; + static folly::Indestructible const map{ + factory::makeValuesToNamesMap()}; + auto found = map->find(value); + return found == map->end() ? nullptr : found->second; +} + +bool TEnumTraits<::nebula::meta::cpp2::ID::Type>::findValue(char const* name, type* out) { + using factory = detail::TEnumMapFactory<::nebula::meta::cpp2::ID::Type>; + static folly::Indestructible const map{ + factory::makeNamesToValuesMap()}; + auto found = map->find(name); + return found == map->end() ? false : (*out = found->second, true); +} +}} // apache::thrift +namespace nebula { namespace meta { namespace cpp2 { + +void ID::__clear() { + // clear all fields + if (type_ == Type::__EMPTY__) { return; } + switch(type_) { + case Type::space_id: + destruct(value_.space_id); + break; + case Type::tag_id: + destruct(value_.tag_id); + break; + case Type::edge_type: + destruct(value_.edge_type); + break; + case Type::index_id: + destruct(value_.index_id); + break; + case Type::cluster_id: + destruct(value_.cluster_id); + break; + default: + assert(false); + break; + } + type_ = Type::__EMPTY__; +} + +bool ID::operator==(const ID& rhs) const { + if (type_ != rhs.type_) { return false; } + switch(type_) { + case Type::space_id: + return value_.space_id == rhs.value_.space_id; + case Type::tag_id: + return value_.tag_id == rhs.value_.tag_id; + case Type::edge_type: + return value_.edge_type == rhs.value_.edge_type; + case Type::index_id: + return value_.index_id == rhs.value_.index_id; + case Type::cluster_id: + return value_.cluster_id == rhs.value_.cluster_id; + default: + return true; + } +} + +bool ID::operator<(const ID& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (lhs.type_ != rhs.type_) { + return lhs.type_ < rhs.type_; + } + switch (lhs.type_) { + case Type::space_id: + return lhs.value_.space_id < rhs.value_.space_id; + case Type::tag_id: + return lhs.value_.tag_id < rhs.value_.tag_id; + case Type::edge_type: + return lhs.value_.edge_type < rhs.value_.edge_type; + case Type::index_id: + return lhs.value_.index_id < rhs.value_.index_id; + case Type::cluster_id: + return lhs.value_.cluster_id < rhs.value_.cluster_id; + default: + return false; + } +} + +void swap(ID& a, ID& b) { + ID temp(std::move(a)); + a = std::move(b); + b = std::move(temp); +} + +template void ID::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t ID::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t ID::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t ID::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void ID::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t ID::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t ID::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t ID::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::ColumnTypeDef>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::ColumnTypeDef>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +ColumnTypeDef::ColumnTypeDef(apache::thrift::FragileConstructor, ::nebula::meta::cpp2::PropertyType type__arg, int16_t type_length__arg, ::nebula::meta::cpp2::GeoShape geo_shape__arg) : + type(std::move(type__arg)), + type_length(std::move(type_length__arg)), + geo_shape(std::move(geo_shape__arg)) { + __isset.type_length = true; + __isset.geo_shape = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void ColumnTypeDef::__clear() { + // clear all fields + type = ::nebula::meta::cpp2::PropertyType::UNKNOWN; + type_length = static_cast(0); + geo_shape = ::nebula::meta::cpp2::GeoShape::ANY; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool ColumnTypeDef::operator==(const ColumnTypeDef& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.type == rhs.type)) { + return false; + } + if (lhs.type_length_ref() != rhs.type_length_ref()) { + return false; + } + if (lhs.geo_shape_ref() != rhs.geo_shape_ref()) { + return false; + } + return true; +} + +bool ColumnTypeDef::operator<(const ColumnTypeDef& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.type == rhs.type)) { + return lhs.type < rhs.type; + } + if (lhs.type_length_ref() != rhs.type_length_ref()) { + return lhs.type_length_ref() < rhs.type_length_ref(); + } + if (lhs.geo_shape_ref() != rhs.geo_shape_ref()) { + return lhs.geo_shape_ref() < rhs.geo_shape_ref(); + } + return false; +} + + +void swap(ColumnTypeDef& a, ColumnTypeDef& b) { + using ::std::swap; + swap(a.type_ref().value(), b.type_ref().value()); + swap(a.type_length_ref().value_unchecked(), b.type_length_ref().value_unchecked()); + swap(a.geo_shape_ref().value_unchecked(), b.geo_shape_ref().value_unchecked()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void ColumnTypeDef::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t ColumnTypeDef::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t ColumnTypeDef::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t ColumnTypeDef::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void ColumnTypeDef::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t ColumnTypeDef::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t ColumnTypeDef::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t ColumnTypeDef::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::ColumnDef>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::ColumnDef>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +ColumnDef::ColumnDef() : + nullable(false) {} +THRIFT_IGNORE_ISSET_USE_WARNING_END + + +ColumnDef::~ColumnDef() {} + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +ColumnDef::ColumnDef(apache::thrift::FragileConstructor, ::std::string name__arg, ::nebula::meta::cpp2::ColumnTypeDef type__arg, ::std::string default_value__arg, bool nullable__arg, ::std::string comment__arg) : + name(std::move(name__arg)), + type(std::move(type__arg)), + default_value(std::move(default_value__arg)), + nullable(std::move(nullable__arg)), + comment(std::move(comment__arg)) { + __isset.default_value = true; + __isset.nullable = true; + __isset.comment = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void ColumnDef::__clear() { + // clear all fields + name = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); + type.__clear(); + default_value = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); + nullable = false; + comment = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool ColumnDef::operator==(const ColumnDef& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!apache::thrift::StringTraits::isEqual(lhs.name, rhs.name)) { + return false; + } + if (!(lhs.type == rhs.type)) { + return false; + } + if (lhs.default_value_ref().has_value() != rhs.default_value_ref().has_value()) { + return false; + } + if (lhs.default_value_ref().has_value()) { + if (!apache::thrift::StringTraits::isEqual(lhs.default_value, rhs.default_value)) { + return false; + } + } + if (lhs.nullable_ref() != rhs.nullable_ref()) { + return false; + } + if (lhs.comment_ref().has_value() != rhs.comment_ref().has_value()) { + return false; + } + if (lhs.comment_ref().has_value()) { + if (!apache::thrift::StringTraits::isEqual(lhs.comment, rhs.comment)) { + return false; + } + } + return true; +} + +bool ColumnDef::operator<(const ColumnDef& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!apache::thrift::StringTraits::isEqual(lhs.name, rhs.name)) { + return apache::thrift::StringTraits::isLess(lhs.name, rhs.name); + } + if (!(lhs.type == rhs.type)) { + return lhs.type < rhs.type; + } + if (lhs.default_value_ref().has_value() != rhs.default_value_ref().has_value()) { + return lhs.default_value_ref().has_value() < rhs.default_value_ref().has_value(); + } + if (lhs.default_value_ref().has_value()) { + if (!apache::thrift::StringTraits::isEqual(lhs.default_value, rhs.default_value)) { + return apache::thrift::StringTraits::isLess(lhs.default_value, rhs.default_value); + } + } + if (lhs.nullable_ref() != rhs.nullable_ref()) { + return lhs.nullable_ref() < rhs.nullable_ref(); + } + if (lhs.comment_ref().has_value() != rhs.comment_ref().has_value()) { + return lhs.comment_ref().has_value() < rhs.comment_ref().has_value(); + } + if (lhs.comment_ref().has_value()) { + if (!apache::thrift::StringTraits::isEqual(lhs.comment, rhs.comment)) { + return apache::thrift::StringTraits::isLess(lhs.comment, rhs.comment); + } + } + return false; +} + +const ::nebula::meta::cpp2::ColumnTypeDef& ColumnDef::get_type() const& { + return type; +} + + ::nebula::meta::cpp2::ColumnTypeDef ColumnDef::get_type() && { + return std::move(type); +} + + +void swap(ColumnDef& a, ColumnDef& b) { + using ::std::swap; + swap(a.name_ref().value(), b.name_ref().value()); + swap(a.type_ref().value(), b.type_ref().value()); + swap(a.default_value_ref().value_unchecked(), b.default_value_ref().value_unchecked()); + swap(a.nullable_ref().value_unchecked(), b.nullable_ref().value_unchecked()); + swap(a.comment_ref().value_unchecked(), b.comment_ref().value_unchecked()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void ColumnDef::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t ColumnDef::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t ColumnDef::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t ColumnDef::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void ColumnDef::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t ColumnDef::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t ColumnDef::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t ColumnDef::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + ColumnDef, + ::apache::thrift::type_class::structure, + ::nebula::meta::cpp2::ColumnTypeDef>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + ColumnDef, + ::apache::thrift::type_class::structure, + ::nebula::meta::cpp2::ColumnTypeDef>, + "inconsistent use of nimble option"); + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::SchemaProp>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::SchemaProp>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +SchemaProp::SchemaProp(apache::thrift::FragileConstructor, int64_t ttl_duration__arg, ::std::string ttl_col__arg, ::std::string comment__arg) : + ttl_duration(std::move(ttl_duration__arg)), + ttl_col(std::move(ttl_col__arg)), + comment(std::move(comment__arg)) { + __isset.ttl_duration = true; + __isset.ttl_col = true; + __isset.comment = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void SchemaProp::__clear() { + // clear all fields + ttl_duration = 0; + ttl_col = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); + comment = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool SchemaProp::operator==(const SchemaProp& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (lhs.ttl_duration_ref() != rhs.ttl_duration_ref()) { + return false; + } + if (lhs.ttl_col_ref().has_value() != rhs.ttl_col_ref().has_value()) { + return false; + } + if (lhs.ttl_col_ref().has_value()) { + if (!apache::thrift::StringTraits::isEqual(lhs.ttl_col, rhs.ttl_col)) { + return false; + } + } + if (lhs.comment_ref().has_value() != rhs.comment_ref().has_value()) { + return false; + } + if (lhs.comment_ref().has_value()) { + if (!apache::thrift::StringTraits::isEqual(lhs.comment, rhs.comment)) { + return false; + } + } + return true; +} + +bool SchemaProp::operator<(const SchemaProp& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (lhs.ttl_duration_ref() != rhs.ttl_duration_ref()) { + return lhs.ttl_duration_ref() < rhs.ttl_duration_ref(); + } + if (lhs.ttl_col_ref().has_value() != rhs.ttl_col_ref().has_value()) { + return lhs.ttl_col_ref().has_value() < rhs.ttl_col_ref().has_value(); + } + if (lhs.ttl_col_ref().has_value()) { + if (!apache::thrift::StringTraits::isEqual(lhs.ttl_col, rhs.ttl_col)) { + return apache::thrift::StringTraits::isLess(lhs.ttl_col, rhs.ttl_col); + } + } + if (lhs.comment_ref().has_value() != rhs.comment_ref().has_value()) { + return lhs.comment_ref().has_value() < rhs.comment_ref().has_value(); + } + if (lhs.comment_ref().has_value()) { + if (!apache::thrift::StringTraits::isEqual(lhs.comment, rhs.comment)) { + return apache::thrift::StringTraits::isLess(lhs.comment, rhs.comment); + } + } + return false; +} + + +void swap(SchemaProp& a, SchemaProp& b) { + using ::std::swap; + swap(a.ttl_duration_ref().value_unchecked(), b.ttl_duration_ref().value_unchecked()); + swap(a.ttl_col_ref().value_unchecked(), b.ttl_col_ref().value_unchecked()); + swap(a.comment_ref().value_unchecked(), b.comment_ref().value_unchecked()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void SchemaProp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t SchemaProp::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t SchemaProp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t SchemaProp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void SchemaProp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t SchemaProp::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t SchemaProp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t SchemaProp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::Schema>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::Schema>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +Schema::Schema(apache::thrift::FragileConstructor, ::std::vector< ::nebula::meta::cpp2::ColumnDef> columns__arg, ::nebula::meta::cpp2::SchemaProp schema_prop__arg) : + columns(std::move(columns__arg)), + schema_prop(std::move(schema_prop__arg)) { + __isset.columns = true; + __isset.schema_prop = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void Schema::__clear() { + // clear all fields + columns.clear(); + schema_prop.__clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool Schema::operator==(const Schema& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.columns == rhs.columns)) { + return false; + } + if (!(lhs.schema_prop == rhs.schema_prop)) { + return false; + } + return true; +} + +bool Schema::operator<(const Schema& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.columns == rhs.columns)) { + return lhs.columns < rhs.columns; + } + if (!(lhs.schema_prop == rhs.schema_prop)) { + return lhs.schema_prop < rhs.schema_prop; + } + return false; +} + +const ::std::vector< ::nebula::meta::cpp2::ColumnDef>& Schema::get_columns() const& { + return columns; +} + +::std::vector< ::nebula::meta::cpp2::ColumnDef> Schema::get_columns() && { + return std::move(columns); +} + +const ::nebula::meta::cpp2::SchemaProp& Schema::get_schema_prop() const& { + return schema_prop; +} + + ::nebula::meta::cpp2::SchemaProp Schema::get_schema_prop() && { + return std::move(schema_prop); +} + + +void swap(Schema& a, Schema& b) { + using ::std::swap; + swap(a.columns_ref().value(), b.columns_ref().value()); + swap(a.schema_prop_ref().value(), b.schema_prop_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void Schema::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t Schema::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t Schema::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t Schema::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void Schema::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t Schema::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t Schema::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t Schema::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + Schema, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector< ::nebula::meta::cpp2::ColumnDef>>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + Schema, + ::apache::thrift::type_class::structure, + ::nebula::meta::cpp2::SchemaProp>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + Schema, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector< ::nebula::meta::cpp2::ColumnDef>>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + Schema, + ::apache::thrift::type_class::structure, + ::nebula::meta::cpp2::SchemaProp>, + "inconsistent use of nimble option"); + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::IdName>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::IdName>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +IdName::IdName(apache::thrift::FragileConstructor, ::nebula::meta::cpp2::ID id__arg, ::std::string name__arg) : + id(std::move(id__arg)), + name(std::move(name__arg)) { + __isset.id = true; + __isset.name = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void IdName::__clear() { + // clear all fields + id.__clear(); + name = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool IdName::operator==(const IdName& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.id == rhs.id)) { + return false; + } + if (!apache::thrift::StringTraits::isEqual(lhs.name, rhs.name)) { + return false; + } + return true; +} + +bool IdName::operator<(const IdName& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.id == rhs.id)) { + return lhs.id < rhs.id; + } + if (!apache::thrift::StringTraits::isEqual(lhs.name, rhs.name)) { + return apache::thrift::StringTraits::isLess(lhs.name, rhs.name); + } + return false; +} + +const ::nebula::meta::cpp2::ID& IdName::get_id() const& { + return id; +} + + ::nebula::meta::cpp2::ID IdName::get_id() && { + return std::move(id); +} + + +void swap(IdName& a, IdName& b) { + using ::std::swap; + swap(a.id_ref().value(), b.id_ref().value()); + swap(a.name_ref().value(), b.name_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void IdName::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t IdName::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t IdName::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t IdName::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void IdName::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t IdName::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t IdName::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t IdName::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + IdName, + ::apache::thrift::type_class::variant, + ::nebula::meta::cpp2::ID>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + IdName, + ::apache::thrift::type_class::variant, + ::nebula::meta::cpp2::ID>, + "inconsistent use of nimble option"); + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::SpaceDesc>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::SpaceDesc>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +SpaceDesc::SpaceDesc() : + partition_num(0), + replica_factor(0), + vid_type(::apache::thrift::detail::make_constant< ::nebula::meta::cpp2::ColumnTypeDef>(::apache::thrift::type_class::structure{}, ::apache::thrift::detail::wrap_struct_argument<::apache::thrift::tag::type>( ::nebula::meta::cpp2::PropertyType::FIXED_STRING), ::apache::thrift::detail::wrap_struct_argument<::apache::thrift::tag::type_length>(static_cast(8)))), + isolation_level( ::nebula::meta::cpp2::IsolationLevel::DEFAULT) {} +THRIFT_IGNORE_ISSET_USE_WARNING_END + + +SpaceDesc::~SpaceDesc() {} + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +SpaceDesc::SpaceDesc(apache::thrift::FragileConstructor, ::std::string space_name__arg, int32_t partition_num__arg, int32_t replica_factor__arg, ::std::string charset_name__arg, ::std::string collate_name__arg, ::nebula::meta::cpp2::ColumnTypeDef vid_type__arg, ::std::string group_name__arg, ::nebula::meta::cpp2::IsolationLevel isolation_level__arg, ::std::string comment__arg) : + space_name(std::move(space_name__arg)), + partition_num(std::move(partition_num__arg)), + replica_factor(std::move(replica_factor__arg)), + charset_name(std::move(charset_name__arg)), + collate_name(std::move(collate_name__arg)), + vid_type(std::move(vid_type__arg)), + group_name(std::move(group_name__arg)), + isolation_level(std::move(isolation_level__arg)), + comment(std::move(comment__arg)) { + __isset.space_name = true; + __isset.partition_num = true; + __isset.replica_factor = true; + __isset.charset_name = true; + __isset.collate_name = true; + __isset.vid_type = true; + __isset.group_name = true; + __isset.isolation_level = true; + __isset.comment = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void SpaceDesc::__clear() { + // clear all fields + space_name = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); + partition_num = 0; + replica_factor = 0; + charset_name = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); + collate_name = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); + vid_type.__clear(); + group_name = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); + isolation_level = ::nebula::meta::cpp2::IsolationLevel::DEFAULT; + comment = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool SpaceDesc::operator==(const SpaceDesc& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!apache::thrift::StringTraits::isEqual(lhs.space_name, rhs.space_name)) { + return false; + } + if (!(lhs.partition_num == rhs.partition_num)) { + return false; + } + if (!(lhs.replica_factor == rhs.replica_factor)) { + return false; + } + if (!apache::thrift::StringTraits::isEqual(lhs.charset_name, rhs.charset_name)) { + return false; + } + if (!apache::thrift::StringTraits::isEqual(lhs.collate_name, rhs.collate_name)) { + return false; + } + if (!(lhs.vid_type == rhs.vid_type)) { + return false; + } + if (lhs.group_name_ref().has_value() != rhs.group_name_ref().has_value()) { + return false; + } + if (lhs.group_name_ref().has_value()) { + if (!apache::thrift::StringTraits::isEqual(lhs.group_name, rhs.group_name)) { + return false; + } + } + if (lhs.isolation_level_ref() != rhs.isolation_level_ref()) { + return false; + } + if (lhs.comment_ref().has_value() != rhs.comment_ref().has_value()) { + return false; + } + if (lhs.comment_ref().has_value()) { + if (!apache::thrift::StringTraits::isEqual(lhs.comment, rhs.comment)) { + return false; + } + } + return true; +} + +bool SpaceDesc::operator<(const SpaceDesc& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!apache::thrift::StringTraits::isEqual(lhs.space_name, rhs.space_name)) { + return apache::thrift::StringTraits::isLess(lhs.space_name, rhs.space_name); + } + if (!(lhs.partition_num == rhs.partition_num)) { + return lhs.partition_num < rhs.partition_num; + } + if (!(lhs.replica_factor == rhs.replica_factor)) { + return lhs.replica_factor < rhs.replica_factor; + } + if (!apache::thrift::StringTraits::isEqual(lhs.charset_name, rhs.charset_name)) { + return apache::thrift::StringTraits::isLess(lhs.charset_name, rhs.charset_name); + } + if (!apache::thrift::StringTraits::isEqual(lhs.collate_name, rhs.collate_name)) { + return apache::thrift::StringTraits::isLess(lhs.collate_name, rhs.collate_name); + } + if (!(lhs.vid_type == rhs.vid_type)) { + return lhs.vid_type < rhs.vid_type; + } + if (lhs.group_name_ref().has_value() != rhs.group_name_ref().has_value()) { + return lhs.group_name_ref().has_value() < rhs.group_name_ref().has_value(); + } + if (lhs.group_name_ref().has_value()) { + if (!apache::thrift::StringTraits::isEqual(lhs.group_name, rhs.group_name)) { + return apache::thrift::StringTraits::isLess(lhs.group_name, rhs.group_name); + } + } + if (lhs.isolation_level_ref() != rhs.isolation_level_ref()) { + return lhs.isolation_level_ref() < rhs.isolation_level_ref(); + } + if (lhs.comment_ref().has_value() != rhs.comment_ref().has_value()) { + return lhs.comment_ref().has_value() < rhs.comment_ref().has_value(); + } + if (lhs.comment_ref().has_value()) { + if (!apache::thrift::StringTraits::isEqual(lhs.comment, rhs.comment)) { + return apache::thrift::StringTraits::isLess(lhs.comment, rhs.comment); + } + } + return false; +} + +const ::nebula::meta::cpp2::ColumnTypeDef& SpaceDesc::get_vid_type() const& { + return vid_type; +} + + ::nebula::meta::cpp2::ColumnTypeDef SpaceDesc::get_vid_type() && { + return std::move(vid_type); +} + + +void swap(SpaceDesc& a, SpaceDesc& b) { + using ::std::swap; + swap(a.space_name_ref().value(), b.space_name_ref().value()); + swap(a.partition_num_ref().value(), b.partition_num_ref().value()); + swap(a.replica_factor_ref().value(), b.replica_factor_ref().value()); + swap(a.charset_name_ref().value(), b.charset_name_ref().value()); + swap(a.collate_name_ref().value(), b.collate_name_ref().value()); + swap(a.vid_type_ref().value(), b.vid_type_ref().value()); + swap(a.group_name_ref().value_unchecked(), b.group_name_ref().value_unchecked()); + swap(a.isolation_level_ref().value_unchecked(), b.isolation_level_ref().value_unchecked()); + swap(a.comment_ref().value_unchecked(), b.comment_ref().value_unchecked()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void SpaceDesc::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t SpaceDesc::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t SpaceDesc::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t SpaceDesc::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void SpaceDesc::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t SpaceDesc::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t SpaceDesc::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t SpaceDesc::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + SpaceDesc, + ::apache::thrift::type_class::structure, + ::nebula::meta::cpp2::ColumnTypeDef>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + SpaceDesc, + ::apache::thrift::type_class::structure, + ::nebula::meta::cpp2::ColumnTypeDef>, + "inconsistent use of nimble option"); + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::SpaceItem>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::SpaceItem>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +SpaceItem::SpaceItem(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, ::nebula::meta::cpp2::SpaceDesc properties__arg) : + space_id(std::move(space_id__arg)), + properties(std::move(properties__arg)) { + __isset.space_id = true; + __isset.properties = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void SpaceItem::__clear() { + // clear all fields + space_id = 0; + properties.__clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool SpaceItem::operator==(const SpaceItem& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return false; + } + if (!(lhs.properties == rhs.properties)) { + return false; + } + return true; +} + +bool SpaceItem::operator<(const SpaceItem& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return lhs.space_id < rhs.space_id; + } + if (!(lhs.properties == rhs.properties)) { + return lhs.properties < rhs.properties; + } + return false; +} + +const ::nebula::meta::cpp2::SpaceDesc& SpaceItem::get_properties() const& { + return properties; +} + + ::nebula::meta::cpp2::SpaceDesc SpaceItem::get_properties() && { + return std::move(properties); +} + + +void swap(SpaceItem& a, SpaceItem& b) { + using ::std::swap; + swap(a.space_id_ref().value(), b.space_id_ref().value()); + swap(a.properties_ref().value(), b.properties_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void SpaceItem::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t SpaceItem::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t SpaceItem::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t SpaceItem::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void SpaceItem::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t SpaceItem::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t SpaceItem::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t SpaceItem::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + SpaceItem, + ::apache::thrift::type_class::structure, + ::nebula::meta::cpp2::SpaceDesc>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + SpaceItem, + ::apache::thrift::type_class::structure, + ::nebula::meta::cpp2::SpaceDesc>, + "inconsistent use of nimble option"); + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::TagItem>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::TagItem>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +TagItem::TagItem(apache::thrift::FragileConstructor, ::nebula::cpp2::TagID tag_id__arg, ::std::string tag_name__arg, ::nebula::meta::cpp2::SchemaVer version__arg, ::nebula::meta::cpp2::Schema schema__arg) : + tag_id(std::move(tag_id__arg)), + tag_name(std::move(tag_name__arg)), + version(std::move(version__arg)), + schema(std::move(schema__arg)) { + __isset.tag_id = true; + __isset.tag_name = true; + __isset.version = true; + __isset.schema = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void TagItem::__clear() { + // clear all fields + tag_id = 0; + tag_name = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); + version = 0; + schema.__clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool TagItem::operator==(const TagItem& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.tag_id == rhs.tag_id)) { + return false; + } + if (!apache::thrift::StringTraits::isEqual(lhs.tag_name, rhs.tag_name)) { + return false; + } + if (!(lhs.version == rhs.version)) { + return false; + } + if (!(lhs.schema == rhs.schema)) { + return false; + } + return true; +} + +bool TagItem::operator<(const TagItem& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.tag_id == rhs.tag_id)) { + return lhs.tag_id < rhs.tag_id; + } + if (!apache::thrift::StringTraits::isEqual(lhs.tag_name, rhs.tag_name)) { + return apache::thrift::StringTraits::isLess(lhs.tag_name, rhs.tag_name); + } + if (!(lhs.version == rhs.version)) { + return lhs.version < rhs.version; + } + if (!(lhs.schema == rhs.schema)) { + return lhs.schema < rhs.schema; + } + return false; +} + +const ::nebula::meta::cpp2::Schema& TagItem::get_schema() const& { + return schema; +} + + ::nebula::meta::cpp2::Schema TagItem::get_schema() && { + return std::move(schema); +} + + +void swap(TagItem& a, TagItem& b) { + using ::std::swap; + swap(a.tag_id_ref().value(), b.tag_id_ref().value()); + swap(a.tag_name_ref().value(), b.tag_name_ref().value()); + swap(a.version_ref().value(), b.version_ref().value()); + swap(a.schema_ref().value(), b.schema_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void TagItem::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t TagItem::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t TagItem::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t TagItem::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void TagItem::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t TagItem::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t TagItem::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t TagItem::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + TagItem, + ::apache::thrift::type_class::structure, + ::nebula::meta::cpp2::Schema>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + TagItem, + ::apache::thrift::type_class::structure, + ::nebula::meta::cpp2::Schema>, + "inconsistent use of nimble option"); + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::AlterSchemaItem>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::AlterSchemaItem>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +AlterSchemaItem::AlterSchemaItem(apache::thrift::FragileConstructor, ::nebula::meta::cpp2::AlterSchemaOp op__arg, ::nebula::meta::cpp2::Schema schema__arg) : + op(std::move(op__arg)), + schema(std::move(schema__arg)) { + __isset.op = true; + __isset.schema = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void AlterSchemaItem::__clear() { + // clear all fields + op = static_cast< ::nebula::meta::cpp2::AlterSchemaOp>(0); + schema.__clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool AlterSchemaItem::operator==(const AlterSchemaItem& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.op == rhs.op)) { + return false; + } + if (!(lhs.schema == rhs.schema)) { + return false; + } + return true; +} + +bool AlterSchemaItem::operator<(const AlterSchemaItem& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.op == rhs.op)) { + return lhs.op < rhs.op; + } + if (!(lhs.schema == rhs.schema)) { + return lhs.schema < rhs.schema; + } + return false; +} + +const ::nebula::meta::cpp2::Schema& AlterSchemaItem::get_schema() const& { + return schema; +} + + ::nebula::meta::cpp2::Schema AlterSchemaItem::get_schema() && { + return std::move(schema); +} + + +void swap(AlterSchemaItem& a, AlterSchemaItem& b) { + using ::std::swap; + swap(a.op_ref().value(), b.op_ref().value()); + swap(a.schema_ref().value(), b.schema_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void AlterSchemaItem::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t AlterSchemaItem::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t AlterSchemaItem::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t AlterSchemaItem::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void AlterSchemaItem::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t AlterSchemaItem::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t AlterSchemaItem::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t AlterSchemaItem::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + AlterSchemaItem, + ::apache::thrift::type_class::structure, + ::nebula::meta::cpp2::Schema>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + AlterSchemaItem, + ::apache::thrift::type_class::structure, + ::nebula::meta::cpp2::Schema>, + "inconsistent use of nimble option"); + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::EdgeItem>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::EdgeItem>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +EdgeItem::EdgeItem(apache::thrift::FragileConstructor, ::nebula::cpp2::EdgeType edge_type__arg, ::std::string edge_name__arg, ::nebula::meta::cpp2::SchemaVer version__arg, ::nebula::meta::cpp2::Schema schema__arg) : + edge_type(std::move(edge_type__arg)), + edge_name(std::move(edge_name__arg)), + version(std::move(version__arg)), + schema(std::move(schema__arg)) { + __isset.edge_type = true; + __isset.edge_name = true; + __isset.version = true; + __isset.schema = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void EdgeItem::__clear() { + // clear all fields + edge_type = 0; + edge_name = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); + version = 0; + schema.__clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool EdgeItem::operator==(const EdgeItem& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.edge_type == rhs.edge_type)) { + return false; + } + if (!apache::thrift::StringTraits::isEqual(lhs.edge_name, rhs.edge_name)) { + return false; + } + if (!(lhs.version == rhs.version)) { + return false; + } + if (!(lhs.schema == rhs.schema)) { + return false; + } + return true; +} + +bool EdgeItem::operator<(const EdgeItem& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.edge_type == rhs.edge_type)) { + return lhs.edge_type < rhs.edge_type; + } + if (!apache::thrift::StringTraits::isEqual(lhs.edge_name, rhs.edge_name)) { + return apache::thrift::StringTraits::isLess(lhs.edge_name, rhs.edge_name); + } + if (!(lhs.version == rhs.version)) { + return lhs.version < rhs.version; + } + if (!(lhs.schema == rhs.schema)) { + return lhs.schema < rhs.schema; + } + return false; +} + +const ::nebula::meta::cpp2::Schema& EdgeItem::get_schema() const& { + return schema; +} + + ::nebula::meta::cpp2::Schema EdgeItem::get_schema() && { + return std::move(schema); +} + + +void swap(EdgeItem& a, EdgeItem& b) { + using ::std::swap; + swap(a.edge_type_ref().value(), b.edge_type_ref().value()); + swap(a.edge_name_ref().value(), b.edge_name_ref().value()); + swap(a.version_ref().value(), b.version_ref().value()); + swap(a.schema_ref().value(), b.schema_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void EdgeItem::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t EdgeItem::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t EdgeItem::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t EdgeItem::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void EdgeItem::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t EdgeItem::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t EdgeItem::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t EdgeItem::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + EdgeItem, + ::apache::thrift::type_class::structure, + ::nebula::meta::cpp2::Schema>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + EdgeItem, + ::apache::thrift::type_class::structure, + ::nebula::meta::cpp2::Schema>, + "inconsistent use of nimble option"); + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::IndexItem>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::IndexItem>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +IndexItem::IndexItem() : + index_id(0) {} +THRIFT_IGNORE_ISSET_USE_WARNING_END + + +IndexItem::~IndexItem() {} + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +IndexItem::IndexItem(apache::thrift::FragileConstructor, ::nebula::cpp2::IndexID index_id__arg, ::std::string index_name__arg, ::nebula::cpp2::SchemaID schema_id__arg, ::std::string schema_name__arg, ::std::vector< ::nebula::meta::cpp2::ColumnDef> fields__arg, ::std::string comment__arg) : + index_id(std::move(index_id__arg)), + index_name(std::move(index_name__arg)), + schema_id(std::move(schema_id__arg)), + schema_name(std::move(schema_name__arg)), + fields(std::move(fields__arg)), + comment(std::move(comment__arg)) { + __isset.index_id = true; + __isset.index_name = true; + __isset.schema_id = true; + __isset.schema_name = true; + __isset.fields = true; + __isset.comment = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void IndexItem::__clear() { + // clear all fields + index_id = 0; + index_name = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); + schema_id.__clear(); + schema_name = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); + fields.clear(); + comment = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool IndexItem::operator==(const IndexItem& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.index_id == rhs.index_id)) { + return false; + } + if (!apache::thrift::StringTraits::isEqual(lhs.index_name, rhs.index_name)) { + return false; + } + if (!(lhs.schema_id == rhs.schema_id)) { + return false; + } + if (!apache::thrift::StringTraits::isEqual(lhs.schema_name, rhs.schema_name)) { + return false; + } + if (!(lhs.fields == rhs.fields)) { + return false; + } + if (lhs.comment_ref().has_value() != rhs.comment_ref().has_value()) { + return false; + } + if (lhs.comment_ref().has_value()) { + if (!apache::thrift::StringTraits::isEqual(lhs.comment, rhs.comment)) { + return false; + } + } + return true; +} + +bool IndexItem::operator<(const IndexItem& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.index_id == rhs.index_id)) { + return lhs.index_id < rhs.index_id; + } + if (!apache::thrift::StringTraits::isEqual(lhs.index_name, rhs.index_name)) { + return apache::thrift::StringTraits::isLess(lhs.index_name, rhs.index_name); + } + if (!(lhs.schema_id == rhs.schema_id)) { + return lhs.schema_id < rhs.schema_id; + } + if (!apache::thrift::StringTraits::isEqual(lhs.schema_name, rhs.schema_name)) { + return apache::thrift::StringTraits::isLess(lhs.schema_name, rhs.schema_name); + } + if (!(lhs.fields == rhs.fields)) { + return lhs.fields < rhs.fields; + } + if (lhs.comment_ref().has_value() != rhs.comment_ref().has_value()) { + return lhs.comment_ref().has_value() < rhs.comment_ref().has_value(); + } + if (lhs.comment_ref().has_value()) { + if (!apache::thrift::StringTraits::isEqual(lhs.comment, rhs.comment)) { + return apache::thrift::StringTraits::isLess(lhs.comment, rhs.comment); + } + } + return false; +} + +const ::nebula::cpp2::SchemaID& IndexItem::get_schema_id() const& { + return schema_id; +} + + ::nebula::cpp2::SchemaID IndexItem::get_schema_id() && { + return std::move(schema_id); +} + +const ::std::vector< ::nebula::meta::cpp2::ColumnDef>& IndexItem::get_fields() const& { + return fields; +} + +::std::vector< ::nebula::meta::cpp2::ColumnDef> IndexItem::get_fields() && { + return std::move(fields); +} + + +void swap(IndexItem& a, IndexItem& b) { + using ::std::swap; + swap(a.index_id_ref().value(), b.index_id_ref().value()); + swap(a.index_name_ref().value(), b.index_name_ref().value()); + swap(a.schema_id_ref().value(), b.schema_id_ref().value()); + swap(a.schema_name_ref().value(), b.schema_name_ref().value()); + swap(a.fields_ref().value(), b.fields_ref().value()); + swap(a.comment_ref().value_unchecked(), b.comment_ref().value_unchecked()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void IndexItem::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t IndexItem::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t IndexItem::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t IndexItem::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void IndexItem::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t IndexItem::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t IndexItem::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t IndexItem::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + IndexItem, + ::apache::thrift::type_class::variant, + ::nebula::cpp2::SchemaID>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + IndexItem, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector< ::nebula::meta::cpp2::ColumnDef>>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + IndexItem, + ::apache::thrift::type_class::variant, + ::nebula::cpp2::SchemaID>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + IndexItem, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector< ::nebula::meta::cpp2::ColumnDef>>, + "inconsistent use of nimble option"); + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::HostItem>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::HostItem>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +HostItem::HostItem() : + status( ::nebula::meta::cpp2::HostStatus::ONLINE), + role( ::nebula::meta::cpp2::HostRole::GRAPH) {} +THRIFT_IGNORE_ISSET_USE_WARNING_END + + +HostItem::~HostItem() {} + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +HostItem::HostItem(apache::thrift::FragileConstructor, nebula::HostAddr hostAddr__arg, ::nebula::meta::cpp2::HostStatus status__arg, std::unordered_map<::std::string, ::std::vector< ::nebula::cpp2::PartitionID>> leader_parts__arg, std::unordered_map<::std::string, ::std::vector< ::nebula::cpp2::PartitionID>> all_parts__arg, ::nebula::meta::cpp2::HostRole role__arg, ::std::string git_info_sha__arg, ::std::string zone_name__arg, ::std::string version__arg) : + hostAddr(std::move(hostAddr__arg)), + status(std::move(status__arg)), + leader_parts(std::move(leader_parts__arg)), + all_parts(std::move(all_parts__arg)), + role(std::move(role__arg)), + git_info_sha(std::move(git_info_sha__arg)), + zone_name(std::move(zone_name__arg)), + version(std::move(version__arg)) { + __isset.hostAddr = true; + __isset.status = true; + __isset.leader_parts = true; + __isset.all_parts = true; + __isset.role = true; + __isset.git_info_sha = true; + __isset.zone_name = true; + __isset.version = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void HostItem::__clear() { + // clear all fields + hostAddr.__clear(); + status = ::nebula::meta::cpp2::HostStatus::ONLINE; + leader_parts.clear(); + all_parts.clear(); + role = ::nebula::meta::cpp2::HostRole::GRAPH; + git_info_sha = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); + zone_name = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); + version = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool HostItem::operator==(const HostItem& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.hostAddr == rhs.hostAddr)) { + return false; + } + if (!(lhs.status == rhs.status)) { + return false; + } + if (!(lhs.leader_parts == rhs.leader_parts)) { + return false; + } + if (!(lhs.all_parts == rhs.all_parts)) { + return false; + } + if (!(lhs.role == rhs.role)) { + return false; + } + if (!apache::thrift::StringTraits::isEqual(lhs.git_info_sha, rhs.git_info_sha)) { + return false; + } + if (lhs.zone_name_ref().has_value() != rhs.zone_name_ref().has_value()) { + return false; + } + if (lhs.zone_name_ref().has_value()) { + if (!apache::thrift::StringTraits::isEqual(lhs.zone_name, rhs.zone_name)) { + return false; + } + } + if (lhs.version_ref().has_value() != rhs.version_ref().has_value()) { + return false; + } + if (lhs.version_ref().has_value()) { + if (!apache::thrift::StringTraits::isEqual(lhs.version, rhs.version)) { + return false; + } + } + return true; +} + +const nebula::HostAddr& HostItem::get_hostAddr() const& { + return hostAddr; +} + +nebula::HostAddr HostItem::get_hostAddr() && { + return std::move(hostAddr); +} + +const std::unordered_map<::std::string, ::std::vector< ::nebula::cpp2::PartitionID>>& HostItem::get_leader_parts() const& { + return leader_parts; +} + +std::unordered_map<::std::string, ::std::vector< ::nebula::cpp2::PartitionID>> HostItem::get_leader_parts() && { + return std::move(leader_parts); +} + +const std::unordered_map<::std::string, ::std::vector< ::nebula::cpp2::PartitionID>>& HostItem::get_all_parts() const& { + return all_parts; +} + +std::unordered_map<::std::string, ::std::vector< ::nebula::cpp2::PartitionID>> HostItem::get_all_parts() && { + return std::move(all_parts); +} + + +void swap(HostItem& a, HostItem& b) { + using ::std::swap; + swap(a.hostAddr_ref().value(), b.hostAddr_ref().value()); + swap(a.status_ref().value(), b.status_ref().value()); + swap(a.leader_parts_ref().value(), b.leader_parts_ref().value()); + swap(a.all_parts_ref().value(), b.all_parts_ref().value()); + swap(a.role_ref().value(), b.role_ref().value()); + swap(a.git_info_sha_ref().value(), b.git_info_sha_ref().value()); + swap(a.zone_name_ref().value_unchecked(), b.zone_name_ref().value_unchecked()); + swap(a.version_ref().value_unchecked(), b.version_ref().value_unchecked()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void HostItem::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t HostItem::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t HostItem::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t HostItem::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void HostItem::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t HostItem::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t HostItem::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t HostItem::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + HostItem, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + HostItem, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of nimble option"); + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::UserItem>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::UserItem>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +UserItem::UserItem() : + is_lock(0), + max_queries_per_hour(0), + max_updates_per_hour(0), + max_connections_per_hour(0), + max_user_connections(0) {} +THRIFT_IGNORE_ISSET_USE_WARNING_END + + +UserItem::~UserItem() {} + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +UserItem::UserItem(apache::thrift::FragileConstructor, ::std::string account__arg, bool is_lock__arg, int32_t max_queries_per_hour__arg, int32_t max_updates_per_hour__arg, int32_t max_connections_per_hour__arg, int32_t max_user_connections__arg) : + account(std::move(account__arg)), + is_lock(std::move(is_lock__arg)), + max_queries_per_hour(std::move(max_queries_per_hour__arg)), + max_updates_per_hour(std::move(max_updates_per_hour__arg)), + max_connections_per_hour(std::move(max_connections_per_hour__arg)), + max_user_connections(std::move(max_user_connections__arg)) { + __isset.account = true; + __isset.is_lock = true; + __isset.max_queries_per_hour = true; + __isset.max_updates_per_hour = true; + __isset.max_connections_per_hour = true; + __isset.max_user_connections = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void UserItem::__clear() { + // clear all fields + account = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); + is_lock = 0; + max_queries_per_hour = 0; + max_updates_per_hour = 0; + max_connections_per_hour = 0; + max_user_connections = 0; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool UserItem::operator==(const UserItem& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!apache::thrift::StringTraits::isEqual(lhs.account, rhs.account)) { + return false; + } + if (!(lhs.is_lock == rhs.is_lock)) { + return false; + } + if (!(lhs.max_queries_per_hour == rhs.max_queries_per_hour)) { + return false; + } + if (!(lhs.max_updates_per_hour == rhs.max_updates_per_hour)) { + return false; + } + if (!(lhs.max_connections_per_hour == rhs.max_connections_per_hour)) { + return false; + } + if (!(lhs.max_user_connections == rhs.max_user_connections)) { + return false; + } + return true; +} + +bool UserItem::operator<(const UserItem& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!apache::thrift::StringTraits::isEqual(lhs.account, rhs.account)) { + return apache::thrift::StringTraits::isLess(lhs.account, rhs.account); + } + if (!(lhs.is_lock == rhs.is_lock)) { + return lhs.is_lock < rhs.is_lock; + } + if (!(lhs.max_queries_per_hour == rhs.max_queries_per_hour)) { + return lhs.max_queries_per_hour < rhs.max_queries_per_hour; + } + if (!(lhs.max_updates_per_hour == rhs.max_updates_per_hour)) { + return lhs.max_updates_per_hour < rhs.max_updates_per_hour; + } + if (!(lhs.max_connections_per_hour == rhs.max_connections_per_hour)) { + return lhs.max_connections_per_hour < rhs.max_connections_per_hour; + } + if (!(lhs.max_user_connections == rhs.max_user_connections)) { + return lhs.max_user_connections < rhs.max_user_connections; + } + return false; +} + + +void swap(UserItem& a, UserItem& b) { + using ::std::swap; + swap(a.account_ref().value(), b.account_ref().value()); + swap(a.is_lock_ref().value(), b.is_lock_ref().value()); + swap(a.max_queries_per_hour_ref().value(), b.max_queries_per_hour_ref().value()); + swap(a.max_updates_per_hour_ref().value(), b.max_updates_per_hour_ref().value()); + swap(a.max_connections_per_hour_ref().value(), b.max_connections_per_hour_ref().value()); + swap(a.max_user_connections_ref().value(), b.max_user_connections_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void UserItem::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t UserItem::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t UserItem::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t UserItem::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void UserItem::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t UserItem::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t UserItem::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t UserItem::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::RoleItem>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::RoleItem>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +RoleItem::RoleItem(apache::thrift::FragileConstructor, ::std::string user_id__arg, ::nebula::cpp2::GraphSpaceID space_id__arg, ::nebula::meta::cpp2::RoleType role_type__arg) : + user_id(std::move(user_id__arg)), + space_id(std::move(space_id__arg)), + role_type(std::move(role_type__arg)) { + __isset.user_id = true; + __isset.space_id = true; + __isset.role_type = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void RoleItem::__clear() { + // clear all fields + user_id = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); + space_id = 0; + role_type = static_cast< ::nebula::meta::cpp2::RoleType>(0); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool RoleItem::operator==(const RoleItem& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!apache::thrift::StringTraits::isEqual(lhs.user_id, rhs.user_id)) { + return false; + } + if (!(lhs.space_id == rhs.space_id)) { + return false; + } + if (!(lhs.role_type == rhs.role_type)) { + return false; + } + return true; +} + +bool RoleItem::operator<(const RoleItem& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!apache::thrift::StringTraits::isEqual(lhs.user_id, rhs.user_id)) { + return apache::thrift::StringTraits::isLess(lhs.user_id, rhs.user_id); + } + if (!(lhs.space_id == rhs.space_id)) { + return lhs.space_id < rhs.space_id; + } + if (!(lhs.role_type == rhs.role_type)) { + return lhs.role_type < rhs.role_type; + } + return false; +} + + +void swap(RoleItem& a, RoleItem& b) { + using ::std::swap; + swap(a.user_id_ref().value(), b.user_id_ref().value()); + swap(a.space_id_ref().value(), b.space_id_ref().value()); + swap(a.role_type_ref().value(), b.role_type_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void RoleItem::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t RoleItem::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t RoleItem::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t RoleItem::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void RoleItem::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t RoleItem::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t RoleItem::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t RoleItem::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::ExecResp>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::ExecResp>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +ExecResp::ExecResp(apache::thrift::FragileConstructor, ::nebula::cpp2::ErrorCode code__arg, ::nebula::meta::cpp2::ID id__arg, nebula::HostAddr leader__arg) : + code(std::move(code__arg)), + id(std::move(id__arg)), + leader(std::move(leader__arg)) { + __isset.code = true; + __isset.id = true; + __isset.leader = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void ExecResp::__clear() { + // clear all fields + code = ::nebula::cpp2::ErrorCode::SUCCEEDED; + id.__clear(); + leader.__clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool ExecResp::operator==(const ExecResp& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.code == rhs.code)) { + return false; + } + if (!(lhs.id == rhs.id)) { + return false; + } + if (!(lhs.leader == rhs.leader)) { + return false; + } + return true; +} + +bool ExecResp::operator<(const ExecResp& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.code == rhs.code)) { + return lhs.code < rhs.code; + } + if (!(lhs.id == rhs.id)) { + return lhs.id < rhs.id; + } + if (!(lhs.leader == rhs.leader)) { + return lhs.leader < rhs.leader; + } + return false; +} + +const ::nebula::meta::cpp2::ID& ExecResp::get_id() const& { + return id; +} + + ::nebula::meta::cpp2::ID ExecResp::get_id() && { + return std::move(id); +} + +const nebula::HostAddr& ExecResp::get_leader() const& { + return leader; +} + +nebula::HostAddr ExecResp::get_leader() && { + return std::move(leader); +} + + +void swap(ExecResp& a, ExecResp& b) { + using ::std::swap; + swap(a.code_ref().value(), b.code_ref().value()); + swap(a.id_ref().value(), b.id_ref().value()); + swap(a.leader_ref().value(), b.leader_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void ExecResp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t ExecResp::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t ExecResp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t ExecResp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void ExecResp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t ExecResp::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t ExecResp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t ExecResp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + ExecResp, + ::apache::thrift::type_class::variant, + ::nebula::meta::cpp2::ID>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + ExecResp, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + ExecResp, + ::apache::thrift::type_class::variant, + ::nebula::meta::cpp2::ID>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + ExecResp, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of nimble option"); + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::AdminJobReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::AdminJobReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +AdminJobReq::AdminJobReq(apache::thrift::FragileConstructor, ::nebula::meta::cpp2::AdminJobOp op__arg, ::nebula::meta::cpp2::AdminCmd cmd__arg, ::std::vector<::std::string> paras__arg) : + op(std::move(op__arg)), + cmd(std::move(cmd__arg)), + paras(std::move(paras__arg)) { + __isset.op = true; + __isset.cmd = true; + __isset.paras = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void AdminJobReq::__clear() { + // clear all fields + op = static_cast< ::nebula::meta::cpp2::AdminJobOp>(0); + cmd = ::nebula::meta::cpp2::AdminCmd::COMPACT; + paras.clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool AdminJobReq::operator==(const AdminJobReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.op == rhs.op)) { + return false; + } + if (!(lhs.cmd == rhs.cmd)) { + return false; + } + if (!(lhs.paras == rhs.paras)) { + return false; + } + return true; +} + +bool AdminJobReq::operator<(const AdminJobReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.op == rhs.op)) { + return lhs.op < rhs.op; + } + if (!(lhs.cmd == rhs.cmd)) { + return lhs.cmd < rhs.cmd; + } + if (!(lhs.paras == rhs.paras)) { + return lhs.paras < rhs.paras; + } + return false; +} + +const ::std::vector<::std::string>& AdminJobReq::get_paras() const& { + return paras; +} + +::std::vector<::std::string> AdminJobReq::get_paras() && { + return std::move(paras); +} + + +void swap(AdminJobReq& a, AdminJobReq& b) { + using ::std::swap; + swap(a.op_ref().value(), b.op_ref().value()); + swap(a.cmd_ref().value(), b.cmd_ref().value()); + swap(a.paras_ref().value(), b.paras_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void AdminJobReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t AdminJobReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t AdminJobReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t AdminJobReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void AdminJobReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t AdminJobReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t AdminJobReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t AdminJobReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::JobDesc>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::JobDesc>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +JobDesc::JobDesc() : + id(0), + cmd( ::nebula::meta::cpp2::AdminCmd::COMPACT), + status(static_cast< ::nebula::meta::cpp2::JobStatus>(0)), + start_time(0), + stop_time(0) {} +THRIFT_IGNORE_ISSET_USE_WARNING_END + + +JobDesc::~JobDesc() {} + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +JobDesc::JobDesc(apache::thrift::FragileConstructor, int32_t id__arg, ::nebula::meta::cpp2::AdminCmd cmd__arg, ::std::vector<::std::string> paras__arg, ::nebula::meta::cpp2::JobStatus status__arg, int64_t start_time__arg, int64_t stop_time__arg) : + id(std::move(id__arg)), + cmd(std::move(cmd__arg)), + paras(std::move(paras__arg)), + status(std::move(status__arg)), + start_time(std::move(start_time__arg)), + stop_time(std::move(stop_time__arg)) { + __isset.id = true; + __isset.cmd = true; + __isset.paras = true; + __isset.status = true; + __isset.start_time = true; + __isset.stop_time = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void JobDesc::__clear() { + // clear all fields + id = 0; + cmd = ::nebula::meta::cpp2::AdminCmd::COMPACT; + paras.clear(); + status = static_cast< ::nebula::meta::cpp2::JobStatus>(0); + start_time = 0; + stop_time = 0; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool JobDesc::operator==(const JobDesc& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.id == rhs.id)) { + return false; + } + if (!(lhs.cmd == rhs.cmd)) { + return false; + } + if (!(lhs.paras == rhs.paras)) { + return false; + } + if (!(lhs.status == rhs.status)) { + return false; + } + if (!(lhs.start_time == rhs.start_time)) { + return false; + } + if (!(lhs.stop_time == rhs.stop_time)) { + return false; + } + return true; +} + +bool JobDesc::operator<(const JobDesc& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.id == rhs.id)) { + return lhs.id < rhs.id; + } + if (!(lhs.cmd == rhs.cmd)) { + return lhs.cmd < rhs.cmd; + } + if (!(lhs.paras == rhs.paras)) { + return lhs.paras < rhs.paras; + } + if (!(lhs.status == rhs.status)) { + return lhs.status < rhs.status; + } + if (!(lhs.start_time == rhs.start_time)) { + return lhs.start_time < rhs.start_time; + } + if (!(lhs.stop_time == rhs.stop_time)) { + return lhs.stop_time < rhs.stop_time; + } + return false; +} + +const ::std::vector<::std::string>& JobDesc::get_paras() const& { + return paras; +} + +::std::vector<::std::string> JobDesc::get_paras() && { + return std::move(paras); +} + + +void swap(JobDesc& a, JobDesc& b) { + using ::std::swap; + swap(a.id_ref().value(), b.id_ref().value()); + swap(a.cmd_ref().value(), b.cmd_ref().value()); + swap(a.paras_ref().value(), b.paras_ref().value()); + swap(a.status_ref().value(), b.status_ref().value()); + swap(a.start_time_ref().value(), b.start_time_ref().value()); + swap(a.stop_time_ref().value(), b.stop_time_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void JobDesc::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t JobDesc::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t JobDesc::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t JobDesc::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void JobDesc::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t JobDesc::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t JobDesc::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t JobDesc::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::TaskDesc>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::TaskDesc>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +TaskDesc::TaskDesc(apache::thrift::FragileConstructor, int32_t task_id__arg, nebula::HostAddr host__arg, ::nebula::meta::cpp2::JobStatus status__arg, int64_t start_time__arg, int64_t stop_time__arg, int32_t job_id__arg) : + task_id(std::move(task_id__arg)), + host(std::move(host__arg)), + status(std::move(status__arg)), + start_time(std::move(start_time__arg)), + stop_time(std::move(stop_time__arg)), + job_id(std::move(job_id__arg)) { + __isset.task_id = true; + __isset.host = true; + __isset.status = true; + __isset.start_time = true; + __isset.stop_time = true; + __isset.job_id = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void TaskDesc::__clear() { + // clear all fields + task_id = 0; + host.__clear(); + status = static_cast< ::nebula::meta::cpp2::JobStatus>(0); + start_time = 0; + stop_time = 0; + job_id = 0; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool TaskDesc::operator==(const TaskDesc& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.task_id == rhs.task_id)) { + return false; + } + if (!(lhs.host == rhs.host)) { + return false; + } + if (!(lhs.status == rhs.status)) { + return false; + } + if (!(lhs.start_time == rhs.start_time)) { + return false; + } + if (!(lhs.stop_time == rhs.stop_time)) { + return false; + } + if (!(lhs.job_id == rhs.job_id)) { + return false; + } + return true; +} + +bool TaskDesc::operator<(const TaskDesc& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.task_id == rhs.task_id)) { + return lhs.task_id < rhs.task_id; + } + if (!(lhs.host == rhs.host)) { + return lhs.host < rhs.host; + } + if (!(lhs.status == rhs.status)) { + return lhs.status < rhs.status; + } + if (!(lhs.start_time == rhs.start_time)) { + return lhs.start_time < rhs.start_time; + } + if (!(lhs.stop_time == rhs.stop_time)) { + return lhs.stop_time < rhs.stop_time; + } + if (!(lhs.job_id == rhs.job_id)) { + return lhs.job_id < rhs.job_id; + } + return false; +} + +const nebula::HostAddr& TaskDesc::get_host() const& { + return host; +} + +nebula::HostAddr TaskDesc::get_host() && { + return std::move(host); +} + + +void swap(TaskDesc& a, TaskDesc& b) { + using ::std::swap; + swap(a.task_id_ref().value(), b.task_id_ref().value()); + swap(a.host_ref().value(), b.host_ref().value()); + swap(a.status_ref().value(), b.status_ref().value()); + swap(a.start_time_ref().value(), b.start_time_ref().value()); + swap(a.stop_time_ref().value(), b.stop_time_ref().value()); + swap(a.job_id_ref().value(), b.job_id_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void TaskDesc::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t TaskDesc::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t TaskDesc::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t TaskDesc::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void TaskDesc::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t TaskDesc::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t TaskDesc::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t TaskDesc::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + TaskDesc, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + TaskDesc, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of nimble option"); + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::AdminJobResult>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::AdminJobResult>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +AdminJobResult::AdminJobResult(apache::thrift::FragileConstructor, int32_t job_id__arg, ::std::vector< ::nebula::meta::cpp2::JobDesc> job_desc__arg, ::std::vector< ::nebula::meta::cpp2::TaskDesc> task_desc__arg, int32_t recovered_job_num__arg) : + job_id(std::move(job_id__arg)), + job_desc(std::move(job_desc__arg)), + task_desc(std::move(task_desc__arg)), + recovered_job_num(std::move(recovered_job_num__arg)) { + __isset.job_id = true; + __isset.job_desc = true; + __isset.task_desc = true; + __isset.recovered_job_num = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void AdminJobResult::__clear() { + // clear all fields + job_id = 0; + job_desc.clear(); + task_desc.clear(); + recovered_job_num = 0; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool AdminJobResult::operator==(const AdminJobResult& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (lhs.job_id_ref() != rhs.job_id_ref()) { + return false; + } + if (lhs.job_desc_ref() != rhs.job_desc_ref()) { + return false; + } + if (lhs.task_desc_ref() != rhs.task_desc_ref()) { + return false; + } + if (lhs.recovered_job_num_ref() != rhs.recovered_job_num_ref()) { + return false; + } + return true; +} + +bool AdminJobResult::operator<(const AdminJobResult& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (lhs.job_id_ref() != rhs.job_id_ref()) { + return lhs.job_id_ref() < rhs.job_id_ref(); + } + if (lhs.job_desc_ref() != rhs.job_desc_ref()) { + return lhs.job_desc_ref() < rhs.job_desc_ref(); + } + if (lhs.task_desc_ref() != rhs.task_desc_ref()) { + return lhs.task_desc_ref() < rhs.task_desc_ref(); + } + if (lhs.recovered_job_num_ref() != rhs.recovered_job_num_ref()) { + return lhs.recovered_job_num_ref() < rhs.recovered_job_num_ref(); + } + return false; +} + +const ::std::vector< ::nebula::meta::cpp2::JobDesc>* AdminJobResult::get_job_desc() const& { + return job_desc_ref().has_value() ? std::addressof(job_desc) : nullptr; +} + +::std::vector< ::nebula::meta::cpp2::JobDesc>* AdminJobResult::get_job_desc() & { + return job_desc_ref().has_value() ? std::addressof(job_desc) : nullptr; +} + +const ::std::vector< ::nebula::meta::cpp2::TaskDesc>* AdminJobResult::get_task_desc() const& { + return task_desc_ref().has_value() ? std::addressof(task_desc) : nullptr; +} + +::std::vector< ::nebula::meta::cpp2::TaskDesc>* AdminJobResult::get_task_desc() & { + return task_desc_ref().has_value() ? std::addressof(task_desc) : nullptr; +} + + +void swap(AdminJobResult& a, AdminJobResult& b) { + using ::std::swap; + swap(a.job_id_ref().value_unchecked(), b.job_id_ref().value_unchecked()); + swap(a.job_desc_ref().value_unchecked(), b.job_desc_ref().value_unchecked()); + swap(a.task_desc_ref().value_unchecked(), b.task_desc_ref().value_unchecked()); + swap(a.recovered_job_num_ref().value_unchecked(), b.recovered_job_num_ref().value_unchecked()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void AdminJobResult::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t AdminJobResult::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t AdminJobResult::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t AdminJobResult::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void AdminJobResult::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t AdminJobResult::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t AdminJobResult::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t AdminJobResult::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + AdminJobResult, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector< ::nebula::meta::cpp2::JobDesc>>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + AdminJobResult, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector< ::nebula::meta::cpp2::TaskDesc>>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + AdminJobResult, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector< ::nebula::meta::cpp2::JobDesc>>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + AdminJobResult, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector< ::nebula::meta::cpp2::TaskDesc>>, + "inconsistent use of nimble option"); + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::AdminJobResp>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::AdminJobResp>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +AdminJobResp::AdminJobResp(apache::thrift::FragileConstructor, ::nebula::cpp2::ErrorCode code__arg, nebula::HostAddr leader__arg, ::nebula::meta::cpp2::AdminJobResult result__arg) : + code(std::move(code__arg)), + leader(std::move(leader__arg)), + result(std::move(result__arg)) { + __isset.code = true; + __isset.leader = true; + __isset.result = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void AdminJobResp::__clear() { + // clear all fields + code = ::nebula::cpp2::ErrorCode::SUCCEEDED; + leader.__clear(); + result.__clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool AdminJobResp::operator==(const AdminJobResp& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.code == rhs.code)) { + return false; + } + if (!(lhs.leader == rhs.leader)) { + return false; + } + if (!(lhs.result == rhs.result)) { + return false; + } + return true; +} + +bool AdminJobResp::operator<(const AdminJobResp& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.code == rhs.code)) { + return lhs.code < rhs.code; + } + if (!(lhs.leader == rhs.leader)) { + return lhs.leader < rhs.leader; + } + if (!(lhs.result == rhs.result)) { + return lhs.result < rhs.result; + } + return false; +} + +const nebula::HostAddr& AdminJobResp::get_leader() const& { + return leader; +} + +nebula::HostAddr AdminJobResp::get_leader() && { + return std::move(leader); +} + +const ::nebula::meta::cpp2::AdminJobResult& AdminJobResp::get_result() const& { + return result; +} + + ::nebula::meta::cpp2::AdminJobResult AdminJobResp::get_result() && { + return std::move(result); +} + + +void swap(AdminJobResp& a, AdminJobResp& b) { + using ::std::swap; + swap(a.code_ref().value(), b.code_ref().value()); + swap(a.leader_ref().value(), b.leader_ref().value()); + swap(a.result_ref().value(), b.result_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void AdminJobResp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t AdminJobResp::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t AdminJobResp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t AdminJobResp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void AdminJobResp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t AdminJobResp::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t AdminJobResp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t AdminJobResp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + AdminJobResp, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + AdminJobResp, + ::apache::thrift::type_class::structure, + ::nebula::meta::cpp2::AdminJobResult>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + AdminJobResp, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + AdminJobResp, + ::apache::thrift::type_class::structure, + ::nebula::meta::cpp2::AdminJobResult>, + "inconsistent use of nimble option"); + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::Correlativity>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::Correlativity>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +Correlativity::Correlativity(apache::thrift::FragileConstructor, ::nebula::cpp2::PartitionID part_id__arg, double proportion__arg) : + part_id(std::move(part_id__arg)), + proportion(std::move(proportion__arg)) { + __isset.part_id = true; + __isset.proportion = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void Correlativity::__clear() { + // clear all fields + part_id = 0; + proportion = 0; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool Correlativity::operator==(const Correlativity& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.part_id == rhs.part_id)) { + return false; + } + if (!(lhs.proportion == rhs.proportion)) { + return false; + } + return true; +} + +bool Correlativity::operator<(const Correlativity& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.part_id == rhs.part_id)) { + return lhs.part_id < rhs.part_id; + } + if (!(lhs.proportion == rhs.proportion)) { + return lhs.proportion < rhs.proportion; + } + return false; +} + + +void swap(Correlativity& a, Correlativity& b) { + using ::std::swap; + swap(a.part_id_ref().value(), b.part_id_ref().value()); + swap(a.proportion_ref().value(), b.proportion_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void Correlativity::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t Correlativity::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t Correlativity::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t Correlativity::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void Correlativity::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t Correlativity::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t Correlativity::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t Correlativity::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::StatsItem>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::StatsItem>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +StatsItem::StatsItem() : + space_vertices(0), + space_edges(0), + status(static_cast< ::nebula::meta::cpp2::JobStatus>(0)) {} +THRIFT_IGNORE_ISSET_USE_WARNING_END + + +StatsItem::~StatsItem() {} + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +StatsItem::StatsItem(apache::thrift::FragileConstructor, std::unordered_map<::std::string, int64_t> tag_vertices__arg, std::unordered_map<::std::string, int64_t> edges__arg, int64_t space_vertices__arg, int64_t space_edges__arg, std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::meta::cpp2::Correlativity>> positive_part_correlativity__arg, std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::meta::cpp2::Correlativity>> negative_part_correlativity__arg, ::nebula::meta::cpp2::JobStatus status__arg) : + tag_vertices(std::move(tag_vertices__arg)), + edges(std::move(edges__arg)), + space_vertices(std::move(space_vertices__arg)), + space_edges(std::move(space_edges__arg)), + positive_part_correlativity(std::move(positive_part_correlativity__arg)), + negative_part_correlativity(std::move(negative_part_correlativity__arg)), + status(std::move(status__arg)) { + __isset.tag_vertices = true; + __isset.edges = true; + __isset.space_vertices = true; + __isset.space_edges = true; + __isset.positive_part_correlativity = true; + __isset.negative_part_correlativity = true; + __isset.status = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void StatsItem::__clear() { + // clear all fields + tag_vertices.clear(); + edges.clear(); + space_vertices = 0; + space_edges = 0; + positive_part_correlativity.clear(); + negative_part_correlativity.clear(); + status = static_cast< ::nebula::meta::cpp2::JobStatus>(0); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool StatsItem::operator==(const StatsItem& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.tag_vertices == rhs.tag_vertices)) { + return false; + } + if (!(lhs.edges == rhs.edges)) { + return false; + } + if (!(lhs.space_vertices == rhs.space_vertices)) { + return false; + } + if (!(lhs.space_edges == rhs.space_edges)) { + return false; + } + if (!(lhs.positive_part_correlativity == rhs.positive_part_correlativity)) { + return false; + } + if (!(lhs.negative_part_correlativity == rhs.negative_part_correlativity)) { + return false; + } + if (!(lhs.status == rhs.status)) { + return false; + } + return true; +} + +const std::unordered_map<::std::string, int64_t>& StatsItem::get_tag_vertices() const& { + return tag_vertices; +} + +std::unordered_map<::std::string, int64_t> StatsItem::get_tag_vertices() && { + return std::move(tag_vertices); +} + +const std::unordered_map<::std::string, int64_t>& StatsItem::get_edges() const& { + return edges; +} + +std::unordered_map<::std::string, int64_t> StatsItem::get_edges() && { + return std::move(edges); +} + +const std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::meta::cpp2::Correlativity>>& StatsItem::get_positive_part_correlativity() const& { + return positive_part_correlativity; +} + +std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::meta::cpp2::Correlativity>> StatsItem::get_positive_part_correlativity() && { + return std::move(positive_part_correlativity); +} + +const std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::meta::cpp2::Correlativity>>& StatsItem::get_negative_part_correlativity() const& { + return negative_part_correlativity; +} + +std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::meta::cpp2::Correlativity>> StatsItem::get_negative_part_correlativity() && { + return std::move(negative_part_correlativity); +} + + +void swap(StatsItem& a, StatsItem& b) { + using ::std::swap; + swap(a.tag_vertices_ref().value(), b.tag_vertices_ref().value()); + swap(a.edges_ref().value(), b.edges_ref().value()); + swap(a.space_vertices_ref().value(), b.space_vertices_ref().value()); + swap(a.space_edges_ref().value(), b.space_edges_ref().value()); + swap(a.positive_part_correlativity_ref().value(), b.positive_part_correlativity_ref().value()); + swap(a.negative_part_correlativity_ref().value(), b.negative_part_correlativity_ref().value()); + swap(a.status_ref().value(), b.status_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void StatsItem::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t StatsItem::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t StatsItem::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t StatsItem::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void StatsItem::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t StatsItem::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t StatsItem::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t StatsItem::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + StatsItem, + ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>>, + std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::meta::cpp2::Correlativity>>>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + StatsItem, + ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>>, + std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::meta::cpp2::Correlativity>>>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + StatsItem, + ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>>, + std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::meta::cpp2::Correlativity>>>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + StatsItem, + ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>>, + std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::meta::cpp2::Correlativity>>>, + "inconsistent use of nimble option"); + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::CreateSpaceReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::CreateSpaceReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +CreateSpaceReq::CreateSpaceReq(apache::thrift::FragileConstructor, ::nebula::meta::cpp2::SpaceDesc properties__arg, bool if_not_exists__arg) : + properties(std::move(properties__arg)), + if_not_exists(std::move(if_not_exists__arg)) { + __isset.properties = true; + __isset.if_not_exists = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void CreateSpaceReq::__clear() { + // clear all fields + properties.__clear(); + if_not_exists = 0; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool CreateSpaceReq::operator==(const CreateSpaceReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.properties == rhs.properties)) { + return false; + } + if (!(lhs.if_not_exists == rhs.if_not_exists)) { + return false; + } + return true; +} + +bool CreateSpaceReq::operator<(const CreateSpaceReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.properties == rhs.properties)) { + return lhs.properties < rhs.properties; + } + if (!(lhs.if_not_exists == rhs.if_not_exists)) { + return lhs.if_not_exists < rhs.if_not_exists; + } + return false; +} + +const ::nebula::meta::cpp2::SpaceDesc& CreateSpaceReq::get_properties() const& { + return properties; +} + + ::nebula::meta::cpp2::SpaceDesc CreateSpaceReq::get_properties() && { + return std::move(properties); +} + + +void swap(CreateSpaceReq& a, CreateSpaceReq& b) { + using ::std::swap; + swap(a.properties_ref().value(), b.properties_ref().value()); + swap(a.if_not_exists_ref().value(), b.if_not_exists_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void CreateSpaceReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t CreateSpaceReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t CreateSpaceReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t CreateSpaceReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void CreateSpaceReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t CreateSpaceReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t CreateSpaceReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t CreateSpaceReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + CreateSpaceReq, + ::apache::thrift::type_class::structure, + ::nebula::meta::cpp2::SpaceDesc>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + CreateSpaceReq, + ::apache::thrift::type_class::structure, + ::nebula::meta::cpp2::SpaceDesc>, + "inconsistent use of nimble option"); + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::CreateSpaceAsReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::CreateSpaceAsReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +CreateSpaceAsReq::CreateSpaceAsReq(apache::thrift::FragileConstructor, ::std::string old_space_name__arg, ::std::string new_space_name__arg) : + old_space_name(std::move(old_space_name__arg)), + new_space_name(std::move(new_space_name__arg)) { + __isset.old_space_name = true; + __isset.new_space_name = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void CreateSpaceAsReq::__clear() { + // clear all fields + old_space_name = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); + new_space_name = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool CreateSpaceAsReq::operator==(const CreateSpaceAsReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!apache::thrift::StringTraits::isEqual(lhs.old_space_name, rhs.old_space_name)) { + return false; + } + if (!apache::thrift::StringTraits::isEqual(lhs.new_space_name, rhs.new_space_name)) { + return false; + } + return true; +} + +bool CreateSpaceAsReq::operator<(const CreateSpaceAsReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!apache::thrift::StringTraits::isEqual(lhs.old_space_name, rhs.old_space_name)) { + return apache::thrift::StringTraits::isLess(lhs.old_space_name, rhs.old_space_name); + } + if (!apache::thrift::StringTraits::isEqual(lhs.new_space_name, rhs.new_space_name)) { + return apache::thrift::StringTraits::isLess(lhs.new_space_name, rhs.new_space_name); + } + return false; +} + + +void swap(CreateSpaceAsReq& a, CreateSpaceAsReq& b) { + using ::std::swap; + swap(a.old_space_name_ref().value(), b.old_space_name_ref().value()); + swap(a.new_space_name_ref().value(), b.new_space_name_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void CreateSpaceAsReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t CreateSpaceAsReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t CreateSpaceAsReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t CreateSpaceAsReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void CreateSpaceAsReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t CreateSpaceAsReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t CreateSpaceAsReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t CreateSpaceAsReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::DropSpaceReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::DropSpaceReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +DropSpaceReq::DropSpaceReq(apache::thrift::FragileConstructor, ::std::string space_name__arg, bool if_exists__arg) : + space_name(std::move(space_name__arg)), + if_exists(std::move(if_exists__arg)) { + __isset.space_name = true; + __isset.if_exists = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void DropSpaceReq::__clear() { + // clear all fields + space_name = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); + if_exists = 0; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool DropSpaceReq::operator==(const DropSpaceReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!apache::thrift::StringTraits::isEqual(lhs.space_name, rhs.space_name)) { + return false; + } + if (!(lhs.if_exists == rhs.if_exists)) { + return false; + } + return true; +} + +bool DropSpaceReq::operator<(const DropSpaceReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!apache::thrift::StringTraits::isEqual(lhs.space_name, rhs.space_name)) { + return apache::thrift::StringTraits::isLess(lhs.space_name, rhs.space_name); + } + if (!(lhs.if_exists == rhs.if_exists)) { + return lhs.if_exists < rhs.if_exists; + } + return false; +} + + +void swap(DropSpaceReq& a, DropSpaceReq& b) { + using ::std::swap; + swap(a.space_name_ref().value(), b.space_name_ref().value()); + swap(a.if_exists_ref().value(), b.if_exists_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void DropSpaceReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t DropSpaceReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t DropSpaceReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t DropSpaceReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void DropSpaceReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t DropSpaceReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t DropSpaceReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t DropSpaceReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::ListSpacesReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::ListSpacesReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +ListSpacesReq::ListSpacesReq(apache::thrift::FragileConstructor) {} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void ListSpacesReq::__clear() { + // clear all fields +} + +bool ListSpacesReq::operator==(const ListSpacesReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + return true; +} + +bool ListSpacesReq::operator<(const ListSpacesReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + return false; +} + + +void swap(ListSpacesReq& a, ListSpacesReq& b) { + using ::std::swap; + (void)a; + (void)b; +} + +template void ListSpacesReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t ListSpacesReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t ListSpacesReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t ListSpacesReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void ListSpacesReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t ListSpacesReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t ListSpacesReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t ListSpacesReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::ListSpacesResp>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::ListSpacesResp>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +ListSpacesResp::ListSpacesResp(apache::thrift::FragileConstructor, ::nebula::cpp2::ErrorCode code__arg, nebula::HostAddr leader__arg, ::std::vector< ::nebula::meta::cpp2::IdName> spaces__arg) : + code(std::move(code__arg)), + leader(std::move(leader__arg)), + spaces(std::move(spaces__arg)) { + __isset.code = true; + __isset.leader = true; + __isset.spaces = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void ListSpacesResp::__clear() { + // clear all fields + code = ::nebula::cpp2::ErrorCode::SUCCEEDED; + leader.__clear(); + spaces.clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool ListSpacesResp::operator==(const ListSpacesResp& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.code == rhs.code)) { + return false; + } + if (!(lhs.leader == rhs.leader)) { + return false; + } + if (!(lhs.spaces == rhs.spaces)) { + return false; + } + return true; +} + +bool ListSpacesResp::operator<(const ListSpacesResp& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.code == rhs.code)) { + return lhs.code < rhs.code; + } + if (!(lhs.leader == rhs.leader)) { + return lhs.leader < rhs.leader; + } + if (!(lhs.spaces == rhs.spaces)) { + return lhs.spaces < rhs.spaces; + } + return false; +} + +const nebula::HostAddr& ListSpacesResp::get_leader() const& { + return leader; +} + +nebula::HostAddr ListSpacesResp::get_leader() && { + return std::move(leader); +} + +const ::std::vector< ::nebula::meta::cpp2::IdName>& ListSpacesResp::get_spaces() const& { + return spaces; +} + +::std::vector< ::nebula::meta::cpp2::IdName> ListSpacesResp::get_spaces() && { + return std::move(spaces); +} + + +void swap(ListSpacesResp& a, ListSpacesResp& b) { + using ::std::swap; + swap(a.code_ref().value(), b.code_ref().value()); + swap(a.leader_ref().value(), b.leader_ref().value()); + swap(a.spaces_ref().value(), b.spaces_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void ListSpacesResp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t ListSpacesResp::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t ListSpacesResp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t ListSpacesResp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void ListSpacesResp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t ListSpacesResp::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t ListSpacesResp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t ListSpacesResp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + ListSpacesResp, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + ListSpacesResp, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector< ::nebula::meta::cpp2::IdName>>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + ListSpacesResp, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + ListSpacesResp, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector< ::nebula::meta::cpp2::IdName>>, + "inconsistent use of nimble option"); + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::GetSpaceReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::GetSpaceReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +GetSpaceReq::GetSpaceReq(apache::thrift::FragileConstructor, ::std::string space_name__arg) : + space_name(std::move(space_name__arg)) { + __isset.space_name = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void GetSpaceReq::__clear() { + // clear all fields + space_name = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool GetSpaceReq::operator==(const GetSpaceReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!apache::thrift::StringTraits::isEqual(lhs.space_name, rhs.space_name)) { + return false; + } + return true; +} + +bool GetSpaceReq::operator<(const GetSpaceReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!apache::thrift::StringTraits::isEqual(lhs.space_name, rhs.space_name)) { + return apache::thrift::StringTraits::isLess(lhs.space_name, rhs.space_name); + } + return false; +} + + +void swap(GetSpaceReq& a, GetSpaceReq& b) { + using ::std::swap; + swap(a.space_name_ref().value(), b.space_name_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void GetSpaceReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t GetSpaceReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t GetSpaceReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t GetSpaceReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void GetSpaceReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t GetSpaceReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t GetSpaceReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t GetSpaceReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::GetSpaceResp>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::GetSpaceResp>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +GetSpaceResp::GetSpaceResp(apache::thrift::FragileConstructor, ::nebula::cpp2::ErrorCode code__arg, nebula::HostAddr leader__arg, ::nebula::meta::cpp2::SpaceItem item__arg) : + code(std::move(code__arg)), + leader(std::move(leader__arg)), + item(std::move(item__arg)) { + __isset.code = true; + __isset.leader = true; + __isset.item = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void GetSpaceResp::__clear() { + // clear all fields + code = ::nebula::cpp2::ErrorCode::SUCCEEDED; + leader.__clear(); + item.__clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool GetSpaceResp::operator==(const GetSpaceResp& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.code == rhs.code)) { + return false; + } + if (!(lhs.leader == rhs.leader)) { + return false; + } + if (!(lhs.item == rhs.item)) { + return false; + } + return true; +} + +bool GetSpaceResp::operator<(const GetSpaceResp& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.code == rhs.code)) { + return lhs.code < rhs.code; + } + if (!(lhs.leader == rhs.leader)) { + return lhs.leader < rhs.leader; + } + if (!(lhs.item == rhs.item)) { + return lhs.item < rhs.item; + } + return false; +} + +const nebula::HostAddr& GetSpaceResp::get_leader() const& { + return leader; +} + +nebula::HostAddr GetSpaceResp::get_leader() && { + return std::move(leader); +} + +const ::nebula::meta::cpp2::SpaceItem& GetSpaceResp::get_item() const& { + return item; +} + + ::nebula::meta::cpp2::SpaceItem GetSpaceResp::get_item() && { + return std::move(item); +} + + +void swap(GetSpaceResp& a, GetSpaceResp& b) { + using ::std::swap; + swap(a.code_ref().value(), b.code_ref().value()); + swap(a.leader_ref().value(), b.leader_ref().value()); + swap(a.item_ref().value(), b.item_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void GetSpaceResp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t GetSpaceResp::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t GetSpaceResp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t GetSpaceResp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void GetSpaceResp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t GetSpaceResp::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t GetSpaceResp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t GetSpaceResp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + GetSpaceResp, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + GetSpaceResp, + ::apache::thrift::type_class::structure, + ::nebula::meta::cpp2::SpaceItem>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + GetSpaceResp, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + GetSpaceResp, + ::apache::thrift::type_class::structure, + ::nebula::meta::cpp2::SpaceItem>, + "inconsistent use of nimble option"); + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::CreateTagReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::CreateTagReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +CreateTagReq::CreateTagReq(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, ::std::string tag_name__arg, ::nebula::meta::cpp2::Schema schema__arg, bool if_not_exists__arg) : + space_id(std::move(space_id__arg)), + tag_name(std::move(tag_name__arg)), + schema(std::move(schema__arg)), + if_not_exists(std::move(if_not_exists__arg)) { + __isset.space_id = true; + __isset.tag_name = true; + __isset.schema = true; + __isset.if_not_exists = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void CreateTagReq::__clear() { + // clear all fields + space_id = 0; + tag_name = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); + schema.__clear(); + if_not_exists = 0; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool CreateTagReq::operator==(const CreateTagReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return false; + } + if (!apache::thrift::StringTraits::isEqual(lhs.tag_name, rhs.tag_name)) { + return false; + } + if (!(lhs.schema == rhs.schema)) { + return false; + } + if (!(lhs.if_not_exists == rhs.if_not_exists)) { + return false; + } + return true; +} + +bool CreateTagReq::operator<(const CreateTagReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return lhs.space_id < rhs.space_id; + } + if (!apache::thrift::StringTraits::isEqual(lhs.tag_name, rhs.tag_name)) { + return apache::thrift::StringTraits::isLess(lhs.tag_name, rhs.tag_name); + } + if (!(lhs.schema == rhs.schema)) { + return lhs.schema < rhs.schema; + } + if (!(lhs.if_not_exists == rhs.if_not_exists)) { + return lhs.if_not_exists < rhs.if_not_exists; + } + return false; +} + +const ::nebula::meta::cpp2::Schema& CreateTagReq::get_schema() const& { + return schema; +} + + ::nebula::meta::cpp2::Schema CreateTagReq::get_schema() && { + return std::move(schema); +} + + +void swap(CreateTagReq& a, CreateTagReq& b) { + using ::std::swap; + swap(a.space_id_ref().value(), b.space_id_ref().value()); + swap(a.tag_name_ref().value(), b.tag_name_ref().value()); + swap(a.schema_ref().value(), b.schema_ref().value()); + swap(a.if_not_exists_ref().value(), b.if_not_exists_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void CreateTagReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t CreateTagReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t CreateTagReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t CreateTagReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void CreateTagReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t CreateTagReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t CreateTagReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t CreateTagReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + CreateTagReq, + ::apache::thrift::type_class::structure, + ::nebula::meta::cpp2::Schema>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + CreateTagReq, + ::apache::thrift::type_class::structure, + ::nebula::meta::cpp2::Schema>, + "inconsistent use of nimble option"); + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::AlterTagReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::AlterTagReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +AlterTagReq::AlterTagReq(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, ::std::string tag_name__arg, ::std::vector< ::nebula::meta::cpp2::AlterSchemaItem> tag_items__arg, ::nebula::meta::cpp2::SchemaProp schema_prop__arg) : + space_id(std::move(space_id__arg)), + tag_name(std::move(tag_name__arg)), + tag_items(std::move(tag_items__arg)), + schema_prop(std::move(schema_prop__arg)) { + __isset.space_id = true; + __isset.tag_name = true; + __isset.tag_items = true; + __isset.schema_prop = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void AlterTagReq::__clear() { + // clear all fields + space_id = 0; + tag_name = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); + tag_items.clear(); + schema_prop.__clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool AlterTagReq::operator==(const AlterTagReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return false; + } + if (!apache::thrift::StringTraits::isEqual(lhs.tag_name, rhs.tag_name)) { + return false; + } + if (!(lhs.tag_items == rhs.tag_items)) { + return false; + } + if (!(lhs.schema_prop == rhs.schema_prop)) { + return false; + } + return true; +} + +bool AlterTagReq::operator<(const AlterTagReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return lhs.space_id < rhs.space_id; + } + if (!apache::thrift::StringTraits::isEqual(lhs.tag_name, rhs.tag_name)) { + return apache::thrift::StringTraits::isLess(lhs.tag_name, rhs.tag_name); + } + if (!(lhs.tag_items == rhs.tag_items)) { + return lhs.tag_items < rhs.tag_items; + } + if (!(lhs.schema_prop == rhs.schema_prop)) { + return lhs.schema_prop < rhs.schema_prop; + } + return false; +} + +const ::std::vector< ::nebula::meta::cpp2::AlterSchemaItem>& AlterTagReq::get_tag_items() const& { + return tag_items; +} + +::std::vector< ::nebula::meta::cpp2::AlterSchemaItem> AlterTagReq::get_tag_items() && { + return std::move(tag_items); +} + +const ::nebula::meta::cpp2::SchemaProp& AlterTagReq::get_schema_prop() const& { + return schema_prop; +} + + ::nebula::meta::cpp2::SchemaProp AlterTagReq::get_schema_prop() && { + return std::move(schema_prop); +} + + +void swap(AlterTagReq& a, AlterTagReq& b) { + using ::std::swap; + swap(a.space_id_ref().value(), b.space_id_ref().value()); + swap(a.tag_name_ref().value(), b.tag_name_ref().value()); + swap(a.tag_items_ref().value(), b.tag_items_ref().value()); + swap(a.schema_prop_ref().value(), b.schema_prop_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void AlterTagReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t AlterTagReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t AlterTagReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t AlterTagReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void AlterTagReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t AlterTagReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t AlterTagReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t AlterTagReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + AlterTagReq, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector< ::nebula::meta::cpp2::AlterSchemaItem>>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + AlterTagReq, + ::apache::thrift::type_class::structure, + ::nebula::meta::cpp2::SchemaProp>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + AlterTagReq, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector< ::nebula::meta::cpp2::AlterSchemaItem>>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + AlterTagReq, + ::apache::thrift::type_class::structure, + ::nebula::meta::cpp2::SchemaProp>, + "inconsistent use of nimble option"); + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::DropTagReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::DropTagReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +DropTagReq::DropTagReq(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, ::std::string tag_name__arg, bool if_exists__arg) : + space_id(std::move(space_id__arg)), + tag_name(std::move(tag_name__arg)), + if_exists(std::move(if_exists__arg)) { + __isset.space_id = true; + __isset.tag_name = true; + __isset.if_exists = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void DropTagReq::__clear() { + // clear all fields + space_id = 0; + tag_name = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); + if_exists = 0; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool DropTagReq::operator==(const DropTagReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return false; + } + if (!apache::thrift::StringTraits::isEqual(lhs.tag_name, rhs.tag_name)) { + return false; + } + if (!(lhs.if_exists == rhs.if_exists)) { + return false; + } + return true; +} + +bool DropTagReq::operator<(const DropTagReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return lhs.space_id < rhs.space_id; + } + if (!apache::thrift::StringTraits::isEqual(lhs.tag_name, rhs.tag_name)) { + return apache::thrift::StringTraits::isLess(lhs.tag_name, rhs.tag_name); + } + if (!(lhs.if_exists == rhs.if_exists)) { + return lhs.if_exists < rhs.if_exists; + } + return false; +} + + +void swap(DropTagReq& a, DropTagReq& b) { + using ::std::swap; + swap(a.space_id_ref().value(), b.space_id_ref().value()); + swap(a.tag_name_ref().value(), b.tag_name_ref().value()); + swap(a.if_exists_ref().value(), b.if_exists_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void DropTagReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t DropTagReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t DropTagReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t DropTagReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void DropTagReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t DropTagReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t DropTagReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t DropTagReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::ListTagsReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::ListTagsReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +ListTagsReq::ListTagsReq(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg) : + space_id(std::move(space_id__arg)) { + __isset.space_id = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void ListTagsReq::__clear() { + // clear all fields + space_id = 0; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool ListTagsReq::operator==(const ListTagsReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return false; + } + return true; +} + +bool ListTagsReq::operator<(const ListTagsReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return lhs.space_id < rhs.space_id; + } + return false; +} + + +void swap(ListTagsReq& a, ListTagsReq& b) { + using ::std::swap; + swap(a.space_id_ref().value(), b.space_id_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void ListTagsReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t ListTagsReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t ListTagsReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t ListTagsReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void ListTagsReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t ListTagsReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t ListTagsReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t ListTagsReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::ListTagsResp>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::ListTagsResp>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +ListTagsResp::ListTagsResp(apache::thrift::FragileConstructor, ::nebula::cpp2::ErrorCode code__arg, nebula::HostAddr leader__arg, ::std::vector< ::nebula::meta::cpp2::TagItem> tags__arg) : + code(std::move(code__arg)), + leader(std::move(leader__arg)), + tags(std::move(tags__arg)) { + __isset.code = true; + __isset.leader = true; + __isset.tags = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void ListTagsResp::__clear() { + // clear all fields + code = ::nebula::cpp2::ErrorCode::SUCCEEDED; + leader.__clear(); + tags.clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool ListTagsResp::operator==(const ListTagsResp& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.code == rhs.code)) { + return false; + } + if (!(lhs.leader == rhs.leader)) { + return false; + } + if (!(lhs.tags == rhs.tags)) { + return false; + } + return true; +} + +bool ListTagsResp::operator<(const ListTagsResp& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.code == rhs.code)) { + return lhs.code < rhs.code; + } + if (!(lhs.leader == rhs.leader)) { + return lhs.leader < rhs.leader; + } + if (!(lhs.tags == rhs.tags)) { + return lhs.tags < rhs.tags; + } + return false; +} + +const nebula::HostAddr& ListTagsResp::get_leader() const& { + return leader; +} + +nebula::HostAddr ListTagsResp::get_leader() && { + return std::move(leader); +} + +const ::std::vector< ::nebula::meta::cpp2::TagItem>& ListTagsResp::get_tags() const& { + return tags; +} + +::std::vector< ::nebula::meta::cpp2::TagItem> ListTagsResp::get_tags() && { + return std::move(tags); +} + + +void swap(ListTagsResp& a, ListTagsResp& b) { + using ::std::swap; + swap(a.code_ref().value(), b.code_ref().value()); + swap(a.leader_ref().value(), b.leader_ref().value()); + swap(a.tags_ref().value(), b.tags_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void ListTagsResp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t ListTagsResp::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t ListTagsResp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t ListTagsResp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void ListTagsResp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t ListTagsResp::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t ListTagsResp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t ListTagsResp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + ListTagsResp, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + ListTagsResp, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector< ::nebula::meta::cpp2::TagItem>>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + ListTagsResp, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + ListTagsResp, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector< ::nebula::meta::cpp2::TagItem>>, + "inconsistent use of nimble option"); + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::GetTagReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::GetTagReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +GetTagReq::GetTagReq(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, ::std::string tag_name__arg, ::nebula::meta::cpp2::SchemaVer version__arg) : + space_id(std::move(space_id__arg)), + tag_name(std::move(tag_name__arg)), + version(std::move(version__arg)) { + __isset.space_id = true; + __isset.tag_name = true; + __isset.version = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void GetTagReq::__clear() { + // clear all fields + space_id = 0; + tag_name = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); + version = 0; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool GetTagReq::operator==(const GetTagReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return false; + } + if (!apache::thrift::StringTraits::isEqual(lhs.tag_name, rhs.tag_name)) { + return false; + } + if (!(lhs.version == rhs.version)) { + return false; + } + return true; +} + +bool GetTagReq::operator<(const GetTagReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return lhs.space_id < rhs.space_id; + } + if (!apache::thrift::StringTraits::isEqual(lhs.tag_name, rhs.tag_name)) { + return apache::thrift::StringTraits::isLess(lhs.tag_name, rhs.tag_name); + } + if (!(lhs.version == rhs.version)) { + return lhs.version < rhs.version; + } + return false; +} + + +void swap(GetTagReq& a, GetTagReq& b) { + using ::std::swap; + swap(a.space_id_ref().value(), b.space_id_ref().value()); + swap(a.tag_name_ref().value(), b.tag_name_ref().value()); + swap(a.version_ref().value(), b.version_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void GetTagReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t GetTagReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t GetTagReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t GetTagReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void GetTagReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t GetTagReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t GetTagReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t GetTagReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::GetTagResp>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::GetTagResp>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +GetTagResp::GetTagResp(apache::thrift::FragileConstructor, ::nebula::cpp2::ErrorCode code__arg, nebula::HostAddr leader__arg, ::nebula::meta::cpp2::Schema schema__arg) : + code(std::move(code__arg)), + leader(std::move(leader__arg)), + schema(std::move(schema__arg)) { + __isset.code = true; + __isset.leader = true; + __isset.schema = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void GetTagResp::__clear() { + // clear all fields + code = ::nebula::cpp2::ErrorCode::SUCCEEDED; + leader.__clear(); + schema.__clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool GetTagResp::operator==(const GetTagResp& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.code == rhs.code)) { + return false; + } + if (!(lhs.leader == rhs.leader)) { + return false; + } + if (!(lhs.schema == rhs.schema)) { + return false; + } + return true; +} + +bool GetTagResp::operator<(const GetTagResp& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.code == rhs.code)) { + return lhs.code < rhs.code; + } + if (!(lhs.leader == rhs.leader)) { + return lhs.leader < rhs.leader; + } + if (!(lhs.schema == rhs.schema)) { + return lhs.schema < rhs.schema; + } + return false; +} + +const nebula::HostAddr& GetTagResp::get_leader() const& { + return leader; +} + +nebula::HostAddr GetTagResp::get_leader() && { + return std::move(leader); +} + +const ::nebula::meta::cpp2::Schema& GetTagResp::get_schema() const& { + return schema; +} + + ::nebula::meta::cpp2::Schema GetTagResp::get_schema() && { + return std::move(schema); +} + + +void swap(GetTagResp& a, GetTagResp& b) { + using ::std::swap; + swap(a.code_ref().value(), b.code_ref().value()); + swap(a.leader_ref().value(), b.leader_ref().value()); + swap(a.schema_ref().value(), b.schema_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void GetTagResp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t GetTagResp::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t GetTagResp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t GetTagResp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void GetTagResp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t GetTagResp::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t GetTagResp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t GetTagResp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + GetTagResp, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + GetTagResp, + ::apache::thrift::type_class::structure, + ::nebula::meta::cpp2::Schema>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + GetTagResp, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + GetTagResp, + ::apache::thrift::type_class::structure, + ::nebula::meta::cpp2::Schema>, + "inconsistent use of nimble option"); + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::CreateEdgeReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::CreateEdgeReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +CreateEdgeReq::CreateEdgeReq(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, ::std::string edge_name__arg, ::nebula::meta::cpp2::Schema schema__arg, bool if_not_exists__arg) : + space_id(std::move(space_id__arg)), + edge_name(std::move(edge_name__arg)), + schema(std::move(schema__arg)), + if_not_exists(std::move(if_not_exists__arg)) { + __isset.space_id = true; + __isset.edge_name = true; + __isset.schema = true; + __isset.if_not_exists = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void CreateEdgeReq::__clear() { + // clear all fields + space_id = 0; + edge_name = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); + schema.__clear(); + if_not_exists = 0; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool CreateEdgeReq::operator==(const CreateEdgeReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return false; + } + if (!apache::thrift::StringTraits::isEqual(lhs.edge_name, rhs.edge_name)) { + return false; + } + if (!(lhs.schema == rhs.schema)) { + return false; + } + if (!(lhs.if_not_exists == rhs.if_not_exists)) { + return false; + } + return true; +} + +bool CreateEdgeReq::operator<(const CreateEdgeReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return lhs.space_id < rhs.space_id; + } + if (!apache::thrift::StringTraits::isEqual(lhs.edge_name, rhs.edge_name)) { + return apache::thrift::StringTraits::isLess(lhs.edge_name, rhs.edge_name); + } + if (!(lhs.schema == rhs.schema)) { + return lhs.schema < rhs.schema; + } + if (!(lhs.if_not_exists == rhs.if_not_exists)) { + return lhs.if_not_exists < rhs.if_not_exists; + } + return false; +} + +const ::nebula::meta::cpp2::Schema& CreateEdgeReq::get_schema() const& { + return schema; +} + + ::nebula::meta::cpp2::Schema CreateEdgeReq::get_schema() && { + return std::move(schema); +} + + +void swap(CreateEdgeReq& a, CreateEdgeReq& b) { + using ::std::swap; + swap(a.space_id_ref().value(), b.space_id_ref().value()); + swap(a.edge_name_ref().value(), b.edge_name_ref().value()); + swap(a.schema_ref().value(), b.schema_ref().value()); + swap(a.if_not_exists_ref().value(), b.if_not_exists_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void CreateEdgeReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t CreateEdgeReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t CreateEdgeReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t CreateEdgeReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void CreateEdgeReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t CreateEdgeReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t CreateEdgeReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t CreateEdgeReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + CreateEdgeReq, + ::apache::thrift::type_class::structure, + ::nebula::meta::cpp2::Schema>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + CreateEdgeReq, + ::apache::thrift::type_class::structure, + ::nebula::meta::cpp2::Schema>, + "inconsistent use of nimble option"); + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::AlterEdgeReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::AlterEdgeReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +AlterEdgeReq::AlterEdgeReq(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, ::std::string edge_name__arg, ::std::vector< ::nebula::meta::cpp2::AlterSchemaItem> edge_items__arg, ::nebula::meta::cpp2::SchemaProp schema_prop__arg) : + space_id(std::move(space_id__arg)), + edge_name(std::move(edge_name__arg)), + edge_items(std::move(edge_items__arg)), + schema_prop(std::move(schema_prop__arg)) { + __isset.space_id = true; + __isset.edge_name = true; + __isset.edge_items = true; + __isset.schema_prop = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void AlterEdgeReq::__clear() { + // clear all fields + space_id = 0; + edge_name = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); + edge_items.clear(); + schema_prop.__clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool AlterEdgeReq::operator==(const AlterEdgeReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return false; + } + if (!apache::thrift::StringTraits::isEqual(lhs.edge_name, rhs.edge_name)) { + return false; + } + if (!(lhs.edge_items == rhs.edge_items)) { + return false; + } + if (!(lhs.schema_prop == rhs.schema_prop)) { + return false; + } + return true; +} + +bool AlterEdgeReq::operator<(const AlterEdgeReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return lhs.space_id < rhs.space_id; + } + if (!apache::thrift::StringTraits::isEqual(lhs.edge_name, rhs.edge_name)) { + return apache::thrift::StringTraits::isLess(lhs.edge_name, rhs.edge_name); + } + if (!(lhs.edge_items == rhs.edge_items)) { + return lhs.edge_items < rhs.edge_items; + } + if (!(lhs.schema_prop == rhs.schema_prop)) { + return lhs.schema_prop < rhs.schema_prop; + } + return false; +} + +const ::std::vector< ::nebula::meta::cpp2::AlterSchemaItem>& AlterEdgeReq::get_edge_items() const& { + return edge_items; +} + +::std::vector< ::nebula::meta::cpp2::AlterSchemaItem> AlterEdgeReq::get_edge_items() && { + return std::move(edge_items); +} + +const ::nebula::meta::cpp2::SchemaProp& AlterEdgeReq::get_schema_prop() const& { + return schema_prop; +} + + ::nebula::meta::cpp2::SchemaProp AlterEdgeReq::get_schema_prop() && { + return std::move(schema_prop); +} + + +void swap(AlterEdgeReq& a, AlterEdgeReq& b) { + using ::std::swap; + swap(a.space_id_ref().value(), b.space_id_ref().value()); + swap(a.edge_name_ref().value(), b.edge_name_ref().value()); + swap(a.edge_items_ref().value(), b.edge_items_ref().value()); + swap(a.schema_prop_ref().value(), b.schema_prop_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void AlterEdgeReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t AlterEdgeReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t AlterEdgeReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t AlterEdgeReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void AlterEdgeReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t AlterEdgeReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t AlterEdgeReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t AlterEdgeReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + AlterEdgeReq, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector< ::nebula::meta::cpp2::AlterSchemaItem>>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + AlterEdgeReq, + ::apache::thrift::type_class::structure, + ::nebula::meta::cpp2::SchemaProp>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + AlterEdgeReq, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector< ::nebula::meta::cpp2::AlterSchemaItem>>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + AlterEdgeReq, + ::apache::thrift::type_class::structure, + ::nebula::meta::cpp2::SchemaProp>, + "inconsistent use of nimble option"); + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::GetEdgeReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::GetEdgeReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +GetEdgeReq::GetEdgeReq(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, ::std::string edge_name__arg, ::nebula::meta::cpp2::SchemaVer version__arg) : + space_id(std::move(space_id__arg)), + edge_name(std::move(edge_name__arg)), + version(std::move(version__arg)) { + __isset.space_id = true; + __isset.edge_name = true; + __isset.version = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void GetEdgeReq::__clear() { + // clear all fields + space_id = 0; + edge_name = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); + version = 0; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool GetEdgeReq::operator==(const GetEdgeReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return false; + } + if (!apache::thrift::StringTraits::isEqual(lhs.edge_name, rhs.edge_name)) { + return false; + } + if (!(lhs.version == rhs.version)) { + return false; + } + return true; +} + +bool GetEdgeReq::operator<(const GetEdgeReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return lhs.space_id < rhs.space_id; + } + if (!apache::thrift::StringTraits::isEqual(lhs.edge_name, rhs.edge_name)) { + return apache::thrift::StringTraits::isLess(lhs.edge_name, rhs.edge_name); + } + if (!(lhs.version == rhs.version)) { + return lhs.version < rhs.version; + } + return false; +} + + +void swap(GetEdgeReq& a, GetEdgeReq& b) { + using ::std::swap; + swap(a.space_id_ref().value(), b.space_id_ref().value()); + swap(a.edge_name_ref().value(), b.edge_name_ref().value()); + swap(a.version_ref().value(), b.version_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void GetEdgeReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t GetEdgeReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t GetEdgeReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t GetEdgeReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void GetEdgeReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t GetEdgeReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t GetEdgeReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t GetEdgeReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::GetEdgeResp>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::GetEdgeResp>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +GetEdgeResp::GetEdgeResp(apache::thrift::FragileConstructor, ::nebula::cpp2::ErrorCode code__arg, nebula::HostAddr leader__arg, ::nebula::meta::cpp2::Schema schema__arg) : + code(std::move(code__arg)), + leader(std::move(leader__arg)), + schema(std::move(schema__arg)) { + __isset.code = true; + __isset.leader = true; + __isset.schema = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void GetEdgeResp::__clear() { + // clear all fields + code = ::nebula::cpp2::ErrorCode::SUCCEEDED; + leader.__clear(); + schema.__clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool GetEdgeResp::operator==(const GetEdgeResp& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.code == rhs.code)) { + return false; + } + if (!(lhs.leader == rhs.leader)) { + return false; + } + if (!(lhs.schema == rhs.schema)) { + return false; + } + return true; +} + +bool GetEdgeResp::operator<(const GetEdgeResp& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.code == rhs.code)) { + return lhs.code < rhs.code; + } + if (!(lhs.leader == rhs.leader)) { + return lhs.leader < rhs.leader; + } + if (!(lhs.schema == rhs.schema)) { + return lhs.schema < rhs.schema; + } + return false; +} + +const nebula::HostAddr& GetEdgeResp::get_leader() const& { + return leader; +} + +nebula::HostAddr GetEdgeResp::get_leader() && { + return std::move(leader); +} + +const ::nebula::meta::cpp2::Schema& GetEdgeResp::get_schema() const& { + return schema; +} + + ::nebula::meta::cpp2::Schema GetEdgeResp::get_schema() && { + return std::move(schema); +} + + +void swap(GetEdgeResp& a, GetEdgeResp& b) { + using ::std::swap; + swap(a.code_ref().value(), b.code_ref().value()); + swap(a.leader_ref().value(), b.leader_ref().value()); + swap(a.schema_ref().value(), b.schema_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void GetEdgeResp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t GetEdgeResp::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t GetEdgeResp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t GetEdgeResp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void GetEdgeResp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t GetEdgeResp::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t GetEdgeResp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t GetEdgeResp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + GetEdgeResp, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + GetEdgeResp, + ::apache::thrift::type_class::structure, + ::nebula::meta::cpp2::Schema>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + GetEdgeResp, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + GetEdgeResp, + ::apache::thrift::type_class::structure, + ::nebula::meta::cpp2::Schema>, + "inconsistent use of nimble option"); + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::DropEdgeReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::DropEdgeReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +DropEdgeReq::DropEdgeReq(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, ::std::string edge_name__arg, bool if_exists__arg) : + space_id(std::move(space_id__arg)), + edge_name(std::move(edge_name__arg)), + if_exists(std::move(if_exists__arg)) { + __isset.space_id = true; + __isset.edge_name = true; + __isset.if_exists = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void DropEdgeReq::__clear() { + // clear all fields + space_id = 0; + edge_name = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); + if_exists = 0; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool DropEdgeReq::operator==(const DropEdgeReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return false; + } + if (!apache::thrift::StringTraits::isEqual(lhs.edge_name, rhs.edge_name)) { + return false; + } + if (!(lhs.if_exists == rhs.if_exists)) { + return false; + } + return true; +} + +bool DropEdgeReq::operator<(const DropEdgeReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return lhs.space_id < rhs.space_id; + } + if (!apache::thrift::StringTraits::isEqual(lhs.edge_name, rhs.edge_name)) { + return apache::thrift::StringTraits::isLess(lhs.edge_name, rhs.edge_name); + } + if (!(lhs.if_exists == rhs.if_exists)) { + return lhs.if_exists < rhs.if_exists; + } + return false; +} + + +void swap(DropEdgeReq& a, DropEdgeReq& b) { + using ::std::swap; + swap(a.space_id_ref().value(), b.space_id_ref().value()); + swap(a.edge_name_ref().value(), b.edge_name_ref().value()); + swap(a.if_exists_ref().value(), b.if_exists_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void DropEdgeReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t DropEdgeReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t DropEdgeReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t DropEdgeReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void DropEdgeReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t DropEdgeReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t DropEdgeReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t DropEdgeReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::ListEdgesReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::ListEdgesReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +ListEdgesReq::ListEdgesReq(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg) : + space_id(std::move(space_id__arg)) { + __isset.space_id = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void ListEdgesReq::__clear() { + // clear all fields + space_id = 0; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool ListEdgesReq::operator==(const ListEdgesReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return false; + } + return true; +} + +bool ListEdgesReq::operator<(const ListEdgesReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return lhs.space_id < rhs.space_id; + } + return false; +} + + +void swap(ListEdgesReq& a, ListEdgesReq& b) { + using ::std::swap; + swap(a.space_id_ref().value(), b.space_id_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void ListEdgesReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t ListEdgesReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t ListEdgesReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t ListEdgesReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void ListEdgesReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t ListEdgesReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t ListEdgesReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t ListEdgesReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::ListEdgesResp>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::ListEdgesResp>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +ListEdgesResp::ListEdgesResp(apache::thrift::FragileConstructor, ::nebula::cpp2::ErrorCode code__arg, nebula::HostAddr leader__arg, ::std::vector< ::nebula::meta::cpp2::EdgeItem> edges__arg) : + code(std::move(code__arg)), + leader(std::move(leader__arg)), + edges(std::move(edges__arg)) { + __isset.code = true; + __isset.leader = true; + __isset.edges = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void ListEdgesResp::__clear() { + // clear all fields + code = ::nebula::cpp2::ErrorCode::SUCCEEDED; + leader.__clear(); + edges.clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool ListEdgesResp::operator==(const ListEdgesResp& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.code == rhs.code)) { + return false; + } + if (!(lhs.leader == rhs.leader)) { + return false; + } + if (!(lhs.edges == rhs.edges)) { + return false; + } + return true; +} + +bool ListEdgesResp::operator<(const ListEdgesResp& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.code == rhs.code)) { + return lhs.code < rhs.code; + } + if (!(lhs.leader == rhs.leader)) { + return lhs.leader < rhs.leader; + } + if (!(lhs.edges == rhs.edges)) { + return lhs.edges < rhs.edges; + } + return false; +} + +const nebula::HostAddr& ListEdgesResp::get_leader() const& { + return leader; +} + +nebula::HostAddr ListEdgesResp::get_leader() && { + return std::move(leader); +} + +const ::std::vector< ::nebula::meta::cpp2::EdgeItem>& ListEdgesResp::get_edges() const& { + return edges; +} + +::std::vector< ::nebula::meta::cpp2::EdgeItem> ListEdgesResp::get_edges() && { + return std::move(edges); +} + + +void swap(ListEdgesResp& a, ListEdgesResp& b) { + using ::std::swap; + swap(a.code_ref().value(), b.code_ref().value()); + swap(a.leader_ref().value(), b.leader_ref().value()); + swap(a.edges_ref().value(), b.edges_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void ListEdgesResp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t ListEdgesResp::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t ListEdgesResp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t ListEdgesResp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void ListEdgesResp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t ListEdgesResp::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t ListEdgesResp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t ListEdgesResp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + ListEdgesResp, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + ListEdgesResp, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector< ::nebula::meta::cpp2::EdgeItem>>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + ListEdgesResp, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + ListEdgesResp, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector< ::nebula::meta::cpp2::EdgeItem>>, + "inconsistent use of nimble option"); + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::ListHostsReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::ListHostsReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +ListHostsReq::ListHostsReq(apache::thrift::FragileConstructor, ::nebula::meta::cpp2::ListHostType type__arg) : + type(std::move(type__arg)) { + __isset.type = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void ListHostsReq::__clear() { + // clear all fields + type = ::nebula::meta::cpp2::ListHostType::ALLOC; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool ListHostsReq::operator==(const ListHostsReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.type == rhs.type)) { + return false; + } + return true; +} + +bool ListHostsReq::operator<(const ListHostsReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.type == rhs.type)) { + return lhs.type < rhs.type; + } + return false; +} + + +void swap(ListHostsReq& a, ListHostsReq& b) { + using ::std::swap; + swap(a.type_ref().value(), b.type_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void ListHostsReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t ListHostsReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t ListHostsReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t ListHostsReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void ListHostsReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t ListHostsReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t ListHostsReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t ListHostsReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::ListHostsResp>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::ListHostsResp>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +ListHostsResp::ListHostsResp(apache::thrift::FragileConstructor, ::nebula::cpp2::ErrorCode code__arg, nebula::HostAddr leader__arg, ::std::vector< ::nebula::meta::cpp2::HostItem> hosts__arg) : + code(std::move(code__arg)), + leader(std::move(leader__arg)), + hosts(std::move(hosts__arg)) { + __isset.code = true; + __isset.leader = true; + __isset.hosts = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void ListHostsResp::__clear() { + // clear all fields + code = ::nebula::cpp2::ErrorCode::SUCCEEDED; + leader.__clear(); + hosts.clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool ListHostsResp::operator==(const ListHostsResp& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.code == rhs.code)) { + return false; + } + if (!(lhs.leader == rhs.leader)) { + return false; + } + if (!(lhs.hosts == rhs.hosts)) { + return false; + } + return true; +} + +const nebula::HostAddr& ListHostsResp::get_leader() const& { + return leader; +} + +nebula::HostAddr ListHostsResp::get_leader() && { + return std::move(leader); +} + +const ::std::vector< ::nebula::meta::cpp2::HostItem>& ListHostsResp::get_hosts() const& { + return hosts; +} + +::std::vector< ::nebula::meta::cpp2::HostItem> ListHostsResp::get_hosts() && { + return std::move(hosts); +} + + +void swap(ListHostsResp& a, ListHostsResp& b) { + using ::std::swap; + swap(a.code_ref().value(), b.code_ref().value()); + swap(a.leader_ref().value(), b.leader_ref().value()); + swap(a.hosts_ref().value(), b.hosts_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void ListHostsResp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t ListHostsResp::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t ListHostsResp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t ListHostsResp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void ListHostsResp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t ListHostsResp::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t ListHostsResp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t ListHostsResp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + ListHostsResp, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + ListHostsResp, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector< ::nebula::meta::cpp2::HostItem>>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + ListHostsResp, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + ListHostsResp, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector< ::nebula::meta::cpp2::HostItem>>, + "inconsistent use of nimble option"); + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::PartItem>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::PartItem>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +PartItem::PartItem(apache::thrift::FragileConstructor, ::nebula::cpp2::PartitionID part_id__arg, nebula::HostAddr leader__arg, ::std::vector peers__arg, ::std::vector losts__arg) : + part_id(std::move(part_id__arg)), + leader(std::move(leader__arg)), + peers(std::move(peers__arg)), + losts(std::move(losts__arg)) { + __isset.leader = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void PartItem::__clear() { + // clear all fields + part_id = 0; + leader.__clear(); + peers.clear(); + losts.clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool PartItem::operator==(const PartItem& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.part_id == rhs.part_id)) { + return false; + } + if (lhs.leader_ref() != rhs.leader_ref()) { + return false; + } + if (!(lhs.peers == rhs.peers)) { + return false; + } + if (!(lhs.losts == rhs.losts)) { + return false; + } + return true; +} + +bool PartItem::operator<(const PartItem& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.part_id == rhs.part_id)) { + return lhs.part_id < rhs.part_id; + } + if (lhs.leader_ref() != rhs.leader_ref()) { + return lhs.leader_ref() < rhs.leader_ref(); + } + if (!(lhs.peers == rhs.peers)) { + return lhs.peers < rhs.peers; + } + if (!(lhs.losts == rhs.losts)) { + return lhs.losts < rhs.losts; + } + return false; +} + +const nebula::HostAddr* PartItem::get_leader() const& { + return leader_ref().has_value() ? std::addressof(leader) : nullptr; +} + +nebula::HostAddr* PartItem::get_leader() & { + return leader_ref().has_value() ? std::addressof(leader) : nullptr; +} + +const ::std::vector& PartItem::get_peers() const& { + return peers; +} + +::std::vector PartItem::get_peers() && { + return std::move(peers); +} + +const ::std::vector& PartItem::get_losts() const& { + return losts; +} + +::std::vector PartItem::get_losts() && { + return std::move(losts); +} + + +void swap(PartItem& a, PartItem& b) { + using ::std::swap; + swap(a.part_id_ref().value(), b.part_id_ref().value()); + swap(a.leader_ref().value_unchecked(), b.leader_ref().value_unchecked()); + swap(a.peers_ref().value(), b.peers_ref().value()); + swap(a.losts_ref().value(), b.losts_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void PartItem::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t PartItem::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t PartItem::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t PartItem::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void PartItem::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t PartItem::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t PartItem::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t PartItem::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + PartItem, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + PartItem, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + PartItem, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + PartItem, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + PartItem, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + PartItem, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector>, + "inconsistent use of nimble option"); + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::ListPartsReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::ListPartsReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +ListPartsReq::ListPartsReq(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, ::std::vector< ::nebula::cpp2::PartitionID> part_ids__arg) : + space_id(std::move(space_id__arg)), + part_ids(std::move(part_ids__arg)) { + __isset.space_id = true; + __isset.part_ids = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void ListPartsReq::__clear() { + // clear all fields + space_id = 0; + part_ids.clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool ListPartsReq::operator==(const ListPartsReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return false; + } + if (!(lhs.part_ids == rhs.part_ids)) { + return false; + } + return true; +} + +bool ListPartsReq::operator<(const ListPartsReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return lhs.space_id < rhs.space_id; + } + if (!(lhs.part_ids == rhs.part_ids)) { + return lhs.part_ids < rhs.part_ids; + } + return false; +} + +const ::std::vector< ::nebula::cpp2::PartitionID>& ListPartsReq::get_part_ids() const& { + return part_ids; +} + +::std::vector< ::nebula::cpp2::PartitionID> ListPartsReq::get_part_ids() && { + return std::move(part_ids); +} + + +void swap(ListPartsReq& a, ListPartsReq& b) { + using ::std::swap; + swap(a.space_id_ref().value(), b.space_id_ref().value()); + swap(a.part_ids_ref().value(), b.part_ids_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void ListPartsReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t ListPartsReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t ListPartsReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t ListPartsReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void ListPartsReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t ListPartsReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t ListPartsReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t ListPartsReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::ListPartsResp>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::ListPartsResp>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +ListPartsResp::ListPartsResp(apache::thrift::FragileConstructor, ::nebula::cpp2::ErrorCode code__arg, nebula::HostAddr leader__arg, ::std::vector< ::nebula::meta::cpp2::PartItem> parts__arg) : + code(std::move(code__arg)), + leader(std::move(leader__arg)), + parts(std::move(parts__arg)) { + __isset.code = true; + __isset.leader = true; + __isset.parts = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void ListPartsResp::__clear() { + // clear all fields + code = ::nebula::cpp2::ErrorCode::SUCCEEDED; + leader.__clear(); + parts.clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool ListPartsResp::operator==(const ListPartsResp& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.code == rhs.code)) { + return false; + } + if (!(lhs.leader == rhs.leader)) { + return false; + } + if (!(lhs.parts == rhs.parts)) { + return false; + } + return true; +} + +bool ListPartsResp::operator<(const ListPartsResp& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.code == rhs.code)) { + return lhs.code < rhs.code; + } + if (!(lhs.leader == rhs.leader)) { + return lhs.leader < rhs.leader; + } + if (!(lhs.parts == rhs.parts)) { + return lhs.parts < rhs.parts; + } + return false; +} + +const nebula::HostAddr& ListPartsResp::get_leader() const& { + return leader; +} + +nebula::HostAddr ListPartsResp::get_leader() && { + return std::move(leader); +} + +const ::std::vector< ::nebula::meta::cpp2::PartItem>& ListPartsResp::get_parts() const& { + return parts; +} + +::std::vector< ::nebula::meta::cpp2::PartItem> ListPartsResp::get_parts() && { + return std::move(parts); +} + + +void swap(ListPartsResp& a, ListPartsResp& b) { + using ::std::swap; + swap(a.code_ref().value(), b.code_ref().value()); + swap(a.leader_ref().value(), b.leader_ref().value()); + swap(a.parts_ref().value(), b.parts_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void ListPartsResp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t ListPartsResp::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t ListPartsResp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t ListPartsResp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void ListPartsResp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t ListPartsResp::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t ListPartsResp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t ListPartsResp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + ListPartsResp, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + ListPartsResp, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector< ::nebula::meta::cpp2::PartItem>>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + ListPartsResp, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + ListPartsResp, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector< ::nebula::meta::cpp2::PartItem>>, + "inconsistent use of nimble option"); + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::GetPartsAllocReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::GetPartsAllocReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +GetPartsAllocReq::GetPartsAllocReq(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg) : + space_id(std::move(space_id__arg)) { + __isset.space_id = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void GetPartsAllocReq::__clear() { + // clear all fields + space_id = 0; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool GetPartsAllocReq::operator==(const GetPartsAllocReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return false; + } + return true; +} + +bool GetPartsAllocReq::operator<(const GetPartsAllocReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return lhs.space_id < rhs.space_id; + } + return false; +} + + +void swap(GetPartsAllocReq& a, GetPartsAllocReq& b) { + using ::std::swap; + swap(a.space_id_ref().value(), b.space_id_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void GetPartsAllocReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t GetPartsAllocReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t GetPartsAllocReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t GetPartsAllocReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void GetPartsAllocReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t GetPartsAllocReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t GetPartsAllocReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t GetPartsAllocReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::GetPartsAllocResp>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::GetPartsAllocResp>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +GetPartsAllocResp::GetPartsAllocResp(apache::thrift::FragileConstructor, ::nebula::cpp2::ErrorCode code__arg, nebula::HostAddr leader__arg, std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector> parts__arg, std::unordered_map< ::nebula::cpp2::PartitionID, int64_t> terms__arg) : + code(std::move(code__arg)), + leader(std::move(leader__arg)), + parts(std::move(parts__arg)), + terms(std::move(terms__arg)) { + __isset.code = true; + __isset.leader = true; + __isset.parts = true; + __isset.terms = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void GetPartsAllocResp::__clear() { + // clear all fields + code = ::nebula::cpp2::ErrorCode::SUCCEEDED; + leader.__clear(); + parts.clear(); + terms.clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool GetPartsAllocResp::operator==(const GetPartsAllocResp& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.code == rhs.code)) { + return false; + } + if (!(lhs.leader == rhs.leader)) { + return false; + } + if (!(lhs.parts == rhs.parts)) { + return false; + } + if (lhs.terms_ref() != rhs.terms_ref()) { + return false; + } + return true; +} + +const nebula::HostAddr& GetPartsAllocResp::get_leader() const& { + return leader; +} + +nebula::HostAddr GetPartsAllocResp::get_leader() && { + return std::move(leader); +} + +const std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector>& GetPartsAllocResp::get_parts() const& { + return parts; +} + +std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector> GetPartsAllocResp::get_parts() && { + return std::move(parts); +} + +const std::unordered_map< ::nebula::cpp2::PartitionID, int64_t>* GetPartsAllocResp::get_terms() const& { + return terms_ref().has_value() ? std::addressof(terms) : nullptr; +} + +std::unordered_map< ::nebula::cpp2::PartitionID, int64_t>* GetPartsAllocResp::get_terms() & { + return terms_ref().has_value() ? std::addressof(terms) : nullptr; +} + + +void swap(GetPartsAllocResp& a, GetPartsAllocResp& b) { + using ::std::swap; + swap(a.code_ref().value(), b.code_ref().value()); + swap(a.leader_ref().value(), b.leader_ref().value()); + swap(a.parts_ref().value(), b.parts_ref().value()); + swap(a.terms_ref().value_unchecked(), b.terms_ref().value_unchecked()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void GetPartsAllocResp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t GetPartsAllocResp::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t GetPartsAllocResp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t GetPartsAllocResp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void GetPartsAllocResp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t GetPartsAllocResp::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t GetPartsAllocResp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t GetPartsAllocResp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + GetPartsAllocResp, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + GetPartsAllocResp, + ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>>, + std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector>>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + GetPartsAllocResp, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + GetPartsAllocResp, + ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>>, + std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector>>, + "inconsistent use of nimble option"); + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::MultiPutReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::MultiPutReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +MultiPutReq::MultiPutReq(apache::thrift::FragileConstructor, ::std::string segment__arg, ::std::vector pairs__arg) : + segment(std::move(segment__arg)), + pairs(std::move(pairs__arg)) { + __isset.segment = true; + __isset.pairs = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void MultiPutReq::__clear() { + // clear all fields + segment = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); + pairs.clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool MultiPutReq::operator==(const MultiPutReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!apache::thrift::StringTraits::isEqual(lhs.segment, rhs.segment)) { + return false; + } + if (!(lhs.pairs == rhs.pairs)) { + return false; + } + return true; +} + +bool MultiPutReq::operator<(const MultiPutReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!apache::thrift::StringTraits::isEqual(lhs.segment, rhs.segment)) { + return apache::thrift::StringTraits::isLess(lhs.segment, rhs.segment); + } + if (!(lhs.pairs == rhs.pairs)) { + return lhs.pairs < rhs.pairs; + } + return false; +} + +const ::std::vector& MultiPutReq::get_pairs() const& { + return pairs; +} + +::std::vector MultiPutReq::get_pairs() && { + return std::move(pairs); +} + + +void swap(MultiPutReq& a, MultiPutReq& b) { + using ::std::swap; + swap(a.segment_ref().value(), b.segment_ref().value()); + swap(a.pairs_ref().value(), b.pairs_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void MultiPutReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t MultiPutReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t MultiPutReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t MultiPutReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void MultiPutReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t MultiPutReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t MultiPutReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t MultiPutReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + MultiPutReq, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + MultiPutReq, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector>, + "inconsistent use of nimble option"); + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::GetReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::GetReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +GetReq::GetReq(apache::thrift::FragileConstructor, ::std::string segment__arg, ::std::string key__arg) : + segment(std::move(segment__arg)), + key(std::move(key__arg)) { + __isset.segment = true; + __isset.key = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void GetReq::__clear() { + // clear all fields + segment = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); + key = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool GetReq::operator==(const GetReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!apache::thrift::StringTraits::isEqual(lhs.segment, rhs.segment)) { + return false; + } + if (!apache::thrift::StringTraits::isEqual(lhs.key, rhs.key)) { + return false; + } + return true; +} + +bool GetReq::operator<(const GetReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!apache::thrift::StringTraits::isEqual(lhs.segment, rhs.segment)) { + return apache::thrift::StringTraits::isLess(lhs.segment, rhs.segment); + } + if (!apache::thrift::StringTraits::isEqual(lhs.key, rhs.key)) { + return apache::thrift::StringTraits::isLess(lhs.key, rhs.key); + } + return false; +} + + +void swap(GetReq& a, GetReq& b) { + using ::std::swap; + swap(a.segment_ref().value(), b.segment_ref().value()); + swap(a.key_ref().value(), b.key_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void GetReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t GetReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t GetReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t GetReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void GetReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t GetReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t GetReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t GetReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::GetResp>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::GetResp>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +GetResp::GetResp(apache::thrift::FragileConstructor, ::nebula::cpp2::ErrorCode code__arg, nebula::HostAddr leader__arg, ::std::string value__arg) : + code(std::move(code__arg)), + leader(std::move(leader__arg)), + value(std::move(value__arg)) { + __isset.code = true; + __isset.leader = true; + __isset.value = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void GetResp::__clear() { + // clear all fields + code = ::nebula::cpp2::ErrorCode::SUCCEEDED; + leader.__clear(); + value = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool GetResp::operator==(const GetResp& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.code == rhs.code)) { + return false; + } + if (!(lhs.leader == rhs.leader)) { + return false; + } + if (!apache::thrift::StringTraits::isEqual(lhs.value, rhs.value)) { + return false; + } + return true; +} + +bool GetResp::operator<(const GetResp& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.code == rhs.code)) { + return lhs.code < rhs.code; + } + if (!(lhs.leader == rhs.leader)) { + return lhs.leader < rhs.leader; + } + if (!apache::thrift::StringTraits::isEqual(lhs.value, rhs.value)) { + return apache::thrift::StringTraits::isLess(lhs.value, rhs.value); + } + return false; +} + +const nebula::HostAddr& GetResp::get_leader() const& { + return leader; +} + +nebula::HostAddr GetResp::get_leader() && { + return std::move(leader); +} + + +void swap(GetResp& a, GetResp& b) { + using ::std::swap; + swap(a.code_ref().value(), b.code_ref().value()); + swap(a.leader_ref().value(), b.leader_ref().value()); + swap(a.value_ref().value(), b.value_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void GetResp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t GetResp::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t GetResp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t GetResp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void GetResp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t GetResp::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t GetResp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t GetResp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + GetResp, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + GetResp, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of nimble option"); + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::MultiGetReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::MultiGetReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +MultiGetReq::MultiGetReq(apache::thrift::FragileConstructor, ::std::string segment__arg, ::std::vector<::std::string> keys__arg) : + segment(std::move(segment__arg)), + keys(std::move(keys__arg)) { + __isset.segment = true; + __isset.keys = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void MultiGetReq::__clear() { + // clear all fields + segment = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); + keys.clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool MultiGetReq::operator==(const MultiGetReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!apache::thrift::StringTraits::isEqual(lhs.segment, rhs.segment)) { + return false; + } + if (!(lhs.keys == rhs.keys)) { + return false; + } + return true; +} + +bool MultiGetReq::operator<(const MultiGetReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!apache::thrift::StringTraits::isEqual(lhs.segment, rhs.segment)) { + return apache::thrift::StringTraits::isLess(lhs.segment, rhs.segment); + } + if (!(lhs.keys == rhs.keys)) { + return lhs.keys < rhs.keys; + } + return false; +} + +const ::std::vector<::std::string>& MultiGetReq::get_keys() const& { + return keys; +} + +::std::vector<::std::string> MultiGetReq::get_keys() && { + return std::move(keys); +} + + +void swap(MultiGetReq& a, MultiGetReq& b) { + using ::std::swap; + swap(a.segment_ref().value(), b.segment_ref().value()); + swap(a.keys_ref().value(), b.keys_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void MultiGetReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t MultiGetReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t MultiGetReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t MultiGetReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void MultiGetReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t MultiGetReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t MultiGetReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t MultiGetReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::MultiGetResp>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::MultiGetResp>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +MultiGetResp::MultiGetResp(apache::thrift::FragileConstructor, ::nebula::cpp2::ErrorCode code__arg, nebula::HostAddr leader__arg, ::std::vector<::std::string> values__arg) : + code(std::move(code__arg)), + leader(std::move(leader__arg)), + values(std::move(values__arg)) { + __isset.code = true; + __isset.leader = true; + __isset.values = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void MultiGetResp::__clear() { + // clear all fields + code = ::nebula::cpp2::ErrorCode::SUCCEEDED; + leader.__clear(); + values.clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool MultiGetResp::operator==(const MultiGetResp& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.code == rhs.code)) { + return false; + } + if (!(lhs.leader == rhs.leader)) { + return false; + } + if (!(lhs.values == rhs.values)) { + return false; + } + return true; +} + +bool MultiGetResp::operator<(const MultiGetResp& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.code == rhs.code)) { + return lhs.code < rhs.code; + } + if (!(lhs.leader == rhs.leader)) { + return lhs.leader < rhs.leader; + } + if (!(lhs.values == rhs.values)) { + return lhs.values < rhs.values; + } + return false; +} + +const nebula::HostAddr& MultiGetResp::get_leader() const& { + return leader; +} + +nebula::HostAddr MultiGetResp::get_leader() && { + return std::move(leader); +} + +const ::std::vector<::std::string>& MultiGetResp::get_values() const& { + return values; +} + +::std::vector<::std::string> MultiGetResp::get_values() && { + return std::move(values); +} + + +void swap(MultiGetResp& a, MultiGetResp& b) { + using ::std::swap; + swap(a.code_ref().value(), b.code_ref().value()); + swap(a.leader_ref().value(), b.leader_ref().value()); + swap(a.values_ref().value(), b.values_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void MultiGetResp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t MultiGetResp::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t MultiGetResp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t MultiGetResp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void MultiGetResp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t MultiGetResp::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t MultiGetResp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t MultiGetResp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + MultiGetResp, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + MultiGetResp, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of nimble option"); + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::RemoveReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::RemoveReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +RemoveReq::RemoveReq(apache::thrift::FragileConstructor, ::std::string segment__arg, ::std::string key__arg) : + segment(std::move(segment__arg)), + key(std::move(key__arg)) { + __isset.segment = true; + __isset.key = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void RemoveReq::__clear() { + // clear all fields + segment = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); + key = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool RemoveReq::operator==(const RemoveReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!apache::thrift::StringTraits::isEqual(lhs.segment, rhs.segment)) { + return false; + } + if (!apache::thrift::StringTraits::isEqual(lhs.key, rhs.key)) { + return false; + } + return true; +} + +bool RemoveReq::operator<(const RemoveReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!apache::thrift::StringTraits::isEqual(lhs.segment, rhs.segment)) { + return apache::thrift::StringTraits::isLess(lhs.segment, rhs.segment); + } + if (!apache::thrift::StringTraits::isEqual(lhs.key, rhs.key)) { + return apache::thrift::StringTraits::isLess(lhs.key, rhs.key); + } + return false; +} + + +void swap(RemoveReq& a, RemoveReq& b) { + using ::std::swap; + swap(a.segment_ref().value(), b.segment_ref().value()); + swap(a.key_ref().value(), b.key_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void RemoveReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t RemoveReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t RemoveReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t RemoveReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void RemoveReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t RemoveReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t RemoveReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t RemoveReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::RemoveRangeReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::RemoveRangeReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +RemoveRangeReq::RemoveRangeReq(apache::thrift::FragileConstructor, ::std::string segment__arg, ::std::string start__arg, ::std::string end__arg) : + segment(std::move(segment__arg)), + start(std::move(start__arg)), + end(std::move(end__arg)) { + __isset.segment = true; + __isset.start = true; + __isset.end = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void RemoveRangeReq::__clear() { + // clear all fields + segment = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); + start = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); + end = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool RemoveRangeReq::operator==(const RemoveRangeReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!apache::thrift::StringTraits::isEqual(lhs.segment, rhs.segment)) { + return false; + } + if (!apache::thrift::StringTraits::isEqual(lhs.start, rhs.start)) { + return false; + } + if (!apache::thrift::StringTraits::isEqual(lhs.end, rhs.end)) { + return false; + } + return true; +} + +bool RemoveRangeReq::operator<(const RemoveRangeReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!apache::thrift::StringTraits::isEqual(lhs.segment, rhs.segment)) { + return apache::thrift::StringTraits::isLess(lhs.segment, rhs.segment); + } + if (!apache::thrift::StringTraits::isEqual(lhs.start, rhs.start)) { + return apache::thrift::StringTraits::isLess(lhs.start, rhs.start); + } + if (!apache::thrift::StringTraits::isEqual(lhs.end, rhs.end)) { + return apache::thrift::StringTraits::isLess(lhs.end, rhs.end); + } + return false; +} + + +void swap(RemoveRangeReq& a, RemoveRangeReq& b) { + using ::std::swap; + swap(a.segment_ref().value(), b.segment_ref().value()); + swap(a.start_ref().value(), b.start_ref().value()); + swap(a.end_ref().value(), b.end_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void RemoveRangeReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t RemoveRangeReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t RemoveRangeReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t RemoveRangeReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void RemoveRangeReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t RemoveRangeReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t RemoveRangeReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t RemoveRangeReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::ScanReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::ScanReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +ScanReq::ScanReq(apache::thrift::FragileConstructor, ::std::string segment__arg, ::std::string start__arg, ::std::string end__arg) : + segment(std::move(segment__arg)), + start(std::move(start__arg)), + end(std::move(end__arg)) { + __isset.segment = true; + __isset.start = true; + __isset.end = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void ScanReq::__clear() { + // clear all fields + segment = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); + start = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); + end = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool ScanReq::operator==(const ScanReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!apache::thrift::StringTraits::isEqual(lhs.segment, rhs.segment)) { + return false; + } + if (!apache::thrift::StringTraits::isEqual(lhs.start, rhs.start)) { + return false; + } + if (!apache::thrift::StringTraits::isEqual(lhs.end, rhs.end)) { + return false; + } + return true; +} + +bool ScanReq::operator<(const ScanReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!apache::thrift::StringTraits::isEqual(lhs.segment, rhs.segment)) { + return apache::thrift::StringTraits::isLess(lhs.segment, rhs.segment); + } + if (!apache::thrift::StringTraits::isEqual(lhs.start, rhs.start)) { + return apache::thrift::StringTraits::isLess(lhs.start, rhs.start); + } + if (!apache::thrift::StringTraits::isEqual(lhs.end, rhs.end)) { + return apache::thrift::StringTraits::isLess(lhs.end, rhs.end); + } + return false; +} + + +void swap(ScanReq& a, ScanReq& b) { + using ::std::swap; + swap(a.segment_ref().value(), b.segment_ref().value()); + swap(a.start_ref().value(), b.start_ref().value()); + swap(a.end_ref().value(), b.end_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void ScanReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t ScanReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t ScanReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t ScanReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void ScanReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t ScanReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t ScanReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t ScanReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::ScanResp>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::ScanResp>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +ScanResp::ScanResp(apache::thrift::FragileConstructor, ::nebula::cpp2::ErrorCode code__arg, nebula::HostAddr leader__arg, ::std::vector<::std::string> values__arg) : + code(std::move(code__arg)), + leader(std::move(leader__arg)), + values(std::move(values__arg)) { + __isset.code = true; + __isset.leader = true; + __isset.values = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void ScanResp::__clear() { + // clear all fields + code = ::nebula::cpp2::ErrorCode::SUCCEEDED; + leader.__clear(); + values.clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool ScanResp::operator==(const ScanResp& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.code == rhs.code)) { + return false; + } + if (!(lhs.leader == rhs.leader)) { + return false; + } + if (!(lhs.values == rhs.values)) { + return false; + } + return true; +} + +bool ScanResp::operator<(const ScanResp& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.code == rhs.code)) { + return lhs.code < rhs.code; + } + if (!(lhs.leader == rhs.leader)) { + return lhs.leader < rhs.leader; + } + if (!(lhs.values == rhs.values)) { + return lhs.values < rhs.values; + } + return false; +} + +const nebula::HostAddr& ScanResp::get_leader() const& { + return leader; +} + +nebula::HostAddr ScanResp::get_leader() && { + return std::move(leader); +} + +const ::std::vector<::std::string>& ScanResp::get_values() const& { + return values; +} + +::std::vector<::std::string> ScanResp::get_values() && { + return std::move(values); +} + + +void swap(ScanResp& a, ScanResp& b) { + using ::std::swap; + swap(a.code_ref().value(), b.code_ref().value()); + swap(a.leader_ref().value(), b.leader_ref().value()); + swap(a.values_ref().value(), b.values_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void ScanResp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t ScanResp::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t ScanResp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t ScanResp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void ScanResp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t ScanResp::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t ScanResp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t ScanResp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + ScanResp, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + ScanResp, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of nimble option"); + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::HBResp>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::HBResp>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +HBResp::HBResp(apache::thrift::FragileConstructor, ::nebula::cpp2::ErrorCode code__arg, nebula::HostAddr leader__arg, ::nebula::meta::cpp2::ClusterID cluster_id__arg, int64_t last_update_time_in_ms__arg, int32_t meta_version__arg) : + code(std::move(code__arg)), + leader(std::move(leader__arg)), + cluster_id(std::move(cluster_id__arg)), + last_update_time_in_ms(std::move(last_update_time_in_ms__arg)), + meta_version(std::move(meta_version__arg)) { + __isset.code = true; + __isset.leader = true; + __isset.cluster_id = true; + __isset.last_update_time_in_ms = true; + __isset.meta_version = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void HBResp::__clear() { + // clear all fields + code = ::nebula::cpp2::ErrorCode::SUCCEEDED; + leader.__clear(); + cluster_id = 0; + last_update_time_in_ms = 0; + meta_version = 0; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool HBResp::operator==(const HBResp& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.code == rhs.code)) { + return false; + } + if (!(lhs.leader == rhs.leader)) { + return false; + } + if (!(lhs.cluster_id == rhs.cluster_id)) { + return false; + } + if (!(lhs.last_update_time_in_ms == rhs.last_update_time_in_ms)) { + return false; + } + if (!(lhs.meta_version == rhs.meta_version)) { + return false; + } + return true; +} + +bool HBResp::operator<(const HBResp& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.code == rhs.code)) { + return lhs.code < rhs.code; + } + if (!(lhs.leader == rhs.leader)) { + return lhs.leader < rhs.leader; + } + if (!(lhs.cluster_id == rhs.cluster_id)) { + return lhs.cluster_id < rhs.cluster_id; + } + if (!(lhs.last_update_time_in_ms == rhs.last_update_time_in_ms)) { + return lhs.last_update_time_in_ms < rhs.last_update_time_in_ms; + } + if (!(lhs.meta_version == rhs.meta_version)) { + return lhs.meta_version < rhs.meta_version; + } + return false; +} + +const nebula::HostAddr& HBResp::get_leader() const& { + return leader; +} + +nebula::HostAddr HBResp::get_leader() && { + return std::move(leader); +} + + +void swap(HBResp& a, HBResp& b) { + using ::std::swap; + swap(a.code_ref().value(), b.code_ref().value()); + swap(a.leader_ref().value(), b.leader_ref().value()); + swap(a.cluster_id_ref().value(), b.cluster_id_ref().value()); + swap(a.last_update_time_in_ms_ref().value(), b.last_update_time_in_ms_ref().value()); + swap(a.meta_version_ref().value(), b.meta_version_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void HBResp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t HBResp::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t HBResp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t HBResp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void HBResp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t HBResp::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t HBResp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t HBResp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + HBResp, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + HBResp, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of nimble option"); + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::LeaderInfo>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::LeaderInfo>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +LeaderInfo::LeaderInfo(apache::thrift::FragileConstructor, ::nebula::cpp2::PartitionID part_id__arg, int64_t term__arg) : + part_id(std::move(part_id__arg)), + term(std::move(term__arg)) { + __isset.part_id = true; + __isset.term = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void LeaderInfo::__clear() { + // clear all fields + part_id = 0; + term = 0; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool LeaderInfo::operator==(const LeaderInfo& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.part_id == rhs.part_id)) { + return false; + } + if (!(lhs.term == rhs.term)) { + return false; + } + return true; +} + +bool LeaderInfo::operator<(const LeaderInfo& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.part_id == rhs.part_id)) { + return lhs.part_id < rhs.part_id; + } + if (!(lhs.term == rhs.term)) { + return lhs.term < rhs.term; + } + return false; +} + + +void swap(LeaderInfo& a, LeaderInfo& b) { + using ::std::swap; + swap(a.part_id_ref().value(), b.part_id_ref().value()); + swap(a.term_ref().value(), b.term_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void LeaderInfo::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t LeaderInfo::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t LeaderInfo::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t LeaderInfo::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void LeaderInfo::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t LeaderInfo::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t LeaderInfo::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t LeaderInfo::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::HBReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::HBReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +HBReq::HBReq() : + role( ::nebula::meta::cpp2::HostRole::GRAPH), + cluster_id(0) {} +THRIFT_IGNORE_ISSET_USE_WARNING_END + + +HBReq::~HBReq() {} + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +HBReq::HBReq(apache::thrift::FragileConstructor, ::nebula::meta::cpp2::HostRole role__arg, nebula::HostAddr host__arg, ::nebula::meta::cpp2::ClusterID cluster_id__arg, std::unordered_map< ::nebula::cpp2::GraphSpaceID, ::std::vector< ::nebula::meta::cpp2::LeaderInfo>> leader_partIds__arg, ::std::string git_info_sha__arg, ::std::string version__arg) : + role(std::move(role__arg)), + host(std::move(host__arg)), + cluster_id(std::move(cluster_id__arg)), + leader_partIds(std::move(leader_partIds__arg)), + git_info_sha(std::move(git_info_sha__arg)), + version(std::move(version__arg)) { + __isset.role = true; + __isset.host = true; + __isset.cluster_id = true; + __isset.leader_partIds = true; + __isset.git_info_sha = true; + __isset.version = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void HBReq::__clear() { + // clear all fields + role = ::nebula::meta::cpp2::HostRole::GRAPH; + host.__clear(); + cluster_id = 0; + leader_partIds.clear(); + git_info_sha = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); + version = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool HBReq::operator==(const HBReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.role == rhs.role)) { + return false; + } + if (!(lhs.host == rhs.host)) { + return false; + } + if (!(lhs.cluster_id == rhs.cluster_id)) { + return false; + } + if (lhs.leader_partIds_ref() != rhs.leader_partIds_ref()) { + return false; + } + if (!apache::thrift::StringTraits::isEqual(lhs.git_info_sha, rhs.git_info_sha)) { + return false; + } + if (lhs.version_ref().has_value() != rhs.version_ref().has_value()) { + return false; + } + if (lhs.version_ref().has_value()) { + if (!apache::thrift::StringTraits::isEqual(lhs.version, rhs.version)) { + return false; + } + } + return true; +} + +const nebula::HostAddr& HBReq::get_host() const& { + return host; +} + +nebula::HostAddr HBReq::get_host() && { + return std::move(host); +} + +const std::unordered_map< ::nebula::cpp2::GraphSpaceID, ::std::vector< ::nebula::meta::cpp2::LeaderInfo>>* HBReq::get_leader_partIds() const& { + return leader_partIds_ref().has_value() ? std::addressof(leader_partIds) : nullptr; +} + +std::unordered_map< ::nebula::cpp2::GraphSpaceID, ::std::vector< ::nebula::meta::cpp2::LeaderInfo>>* HBReq::get_leader_partIds() & { + return leader_partIds_ref().has_value() ? std::addressof(leader_partIds) : nullptr; +} + + +void swap(HBReq& a, HBReq& b) { + using ::std::swap; + swap(a.role_ref().value(), b.role_ref().value()); + swap(a.host_ref().value(), b.host_ref().value()); + swap(a.cluster_id_ref().value(), b.cluster_id_ref().value()); + swap(a.leader_partIds_ref().value_unchecked(), b.leader_partIds_ref().value_unchecked()); + swap(a.git_info_sha_ref().value(), b.git_info_sha_ref().value()); + swap(a.version_ref().value_unchecked(), b.version_ref().value_unchecked()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void HBReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t HBReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t HBReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t HBReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void HBReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t HBReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t HBReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t HBReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + HBReq, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + HBReq, + ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>>, + std::unordered_map< ::nebula::cpp2::GraphSpaceID, ::std::vector< ::nebula::meta::cpp2::LeaderInfo>>>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + HBReq, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + HBReq, + ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>>, + std::unordered_map< ::nebula::cpp2::GraphSpaceID, ::std::vector< ::nebula::meta::cpp2::LeaderInfo>>>, + "inconsistent use of nimble option"); + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::IndexFieldDef>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::IndexFieldDef>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +IndexFieldDef::IndexFieldDef(apache::thrift::FragileConstructor, ::std::string name__arg, int16_t type_length__arg) : + name(std::move(name__arg)), + type_length(std::move(type_length__arg)) { + __isset.type_length = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void IndexFieldDef::__clear() { + // clear all fields + name = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); + type_length = 0; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool IndexFieldDef::operator==(const IndexFieldDef& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!apache::thrift::StringTraits::isEqual(lhs.name, rhs.name)) { + return false; + } + if (lhs.type_length_ref() != rhs.type_length_ref()) { + return false; + } + return true; +} + +bool IndexFieldDef::operator<(const IndexFieldDef& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!apache::thrift::StringTraits::isEqual(lhs.name, rhs.name)) { + return apache::thrift::StringTraits::isLess(lhs.name, rhs.name); + } + if (lhs.type_length_ref() != rhs.type_length_ref()) { + return lhs.type_length_ref() < rhs.type_length_ref(); + } + return false; +} + + +void swap(IndexFieldDef& a, IndexFieldDef& b) { + using ::std::swap; + swap(a.name_ref().value(), b.name_ref().value()); + swap(a.type_length_ref().value_unchecked(), b.type_length_ref().value_unchecked()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void IndexFieldDef::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t IndexFieldDef::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t IndexFieldDef::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t IndexFieldDef::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void IndexFieldDef::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t IndexFieldDef::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t IndexFieldDef::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t IndexFieldDef::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::CreateTagIndexReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::CreateTagIndexReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +CreateTagIndexReq::CreateTagIndexReq() : + space_id(0), + if_not_exists(0) {} +THRIFT_IGNORE_ISSET_USE_WARNING_END + + +CreateTagIndexReq::~CreateTagIndexReq() {} + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +CreateTagIndexReq::CreateTagIndexReq(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, ::std::string index_name__arg, ::std::string tag_name__arg, ::std::vector< ::nebula::meta::cpp2::IndexFieldDef> fields__arg, bool if_not_exists__arg, ::std::string comment__arg) : + space_id(std::move(space_id__arg)), + index_name(std::move(index_name__arg)), + tag_name(std::move(tag_name__arg)), + fields(std::move(fields__arg)), + if_not_exists(std::move(if_not_exists__arg)), + comment(std::move(comment__arg)) { + __isset.space_id = true; + __isset.index_name = true; + __isset.tag_name = true; + __isset.fields = true; + __isset.if_not_exists = true; + __isset.comment = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void CreateTagIndexReq::__clear() { + // clear all fields + space_id = 0; + index_name = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); + tag_name = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); + fields.clear(); + if_not_exists = 0; + comment = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool CreateTagIndexReq::operator==(const CreateTagIndexReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return false; + } + if (!apache::thrift::StringTraits::isEqual(lhs.index_name, rhs.index_name)) { + return false; + } + if (!apache::thrift::StringTraits::isEqual(lhs.tag_name, rhs.tag_name)) { + return false; + } + if (!(lhs.fields == rhs.fields)) { + return false; + } + if (!(lhs.if_not_exists == rhs.if_not_exists)) { + return false; + } + if (lhs.comment_ref().has_value() != rhs.comment_ref().has_value()) { + return false; + } + if (lhs.comment_ref().has_value()) { + if (!apache::thrift::StringTraits::isEqual(lhs.comment, rhs.comment)) { + return false; + } + } + return true; +} + +bool CreateTagIndexReq::operator<(const CreateTagIndexReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return lhs.space_id < rhs.space_id; + } + if (!apache::thrift::StringTraits::isEqual(lhs.index_name, rhs.index_name)) { + return apache::thrift::StringTraits::isLess(lhs.index_name, rhs.index_name); + } + if (!apache::thrift::StringTraits::isEqual(lhs.tag_name, rhs.tag_name)) { + return apache::thrift::StringTraits::isLess(lhs.tag_name, rhs.tag_name); + } + if (!(lhs.fields == rhs.fields)) { + return lhs.fields < rhs.fields; + } + if (!(lhs.if_not_exists == rhs.if_not_exists)) { + return lhs.if_not_exists < rhs.if_not_exists; + } + if (lhs.comment_ref().has_value() != rhs.comment_ref().has_value()) { + return lhs.comment_ref().has_value() < rhs.comment_ref().has_value(); + } + if (lhs.comment_ref().has_value()) { + if (!apache::thrift::StringTraits::isEqual(lhs.comment, rhs.comment)) { + return apache::thrift::StringTraits::isLess(lhs.comment, rhs.comment); + } + } + return false; +} + +const ::std::vector< ::nebula::meta::cpp2::IndexFieldDef>& CreateTagIndexReq::get_fields() const& { + return fields; +} + +::std::vector< ::nebula::meta::cpp2::IndexFieldDef> CreateTagIndexReq::get_fields() && { + return std::move(fields); +} + + +void swap(CreateTagIndexReq& a, CreateTagIndexReq& b) { + using ::std::swap; + swap(a.space_id_ref().value(), b.space_id_ref().value()); + swap(a.index_name_ref().value(), b.index_name_ref().value()); + swap(a.tag_name_ref().value(), b.tag_name_ref().value()); + swap(a.fields_ref().value(), b.fields_ref().value()); + swap(a.if_not_exists_ref().value(), b.if_not_exists_ref().value()); + swap(a.comment_ref().value_unchecked(), b.comment_ref().value_unchecked()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void CreateTagIndexReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t CreateTagIndexReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t CreateTagIndexReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t CreateTagIndexReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void CreateTagIndexReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t CreateTagIndexReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t CreateTagIndexReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t CreateTagIndexReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + CreateTagIndexReq, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector< ::nebula::meta::cpp2::IndexFieldDef>>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + CreateTagIndexReq, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector< ::nebula::meta::cpp2::IndexFieldDef>>, + "inconsistent use of nimble option"); + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::DropTagIndexReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::DropTagIndexReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +DropTagIndexReq::DropTagIndexReq(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, ::std::string index_name__arg, bool if_exists__arg) : + space_id(std::move(space_id__arg)), + index_name(std::move(index_name__arg)), + if_exists(std::move(if_exists__arg)) { + __isset.space_id = true; + __isset.index_name = true; + __isset.if_exists = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void DropTagIndexReq::__clear() { + // clear all fields + space_id = 0; + index_name = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); + if_exists = 0; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool DropTagIndexReq::operator==(const DropTagIndexReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return false; + } + if (!apache::thrift::StringTraits::isEqual(lhs.index_name, rhs.index_name)) { + return false; + } + if (!(lhs.if_exists == rhs.if_exists)) { + return false; + } + return true; +} + +bool DropTagIndexReq::operator<(const DropTagIndexReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return lhs.space_id < rhs.space_id; + } + if (!apache::thrift::StringTraits::isEqual(lhs.index_name, rhs.index_name)) { + return apache::thrift::StringTraits::isLess(lhs.index_name, rhs.index_name); + } + if (!(lhs.if_exists == rhs.if_exists)) { + return lhs.if_exists < rhs.if_exists; + } + return false; +} + + +void swap(DropTagIndexReq& a, DropTagIndexReq& b) { + using ::std::swap; + swap(a.space_id_ref().value(), b.space_id_ref().value()); + swap(a.index_name_ref().value(), b.index_name_ref().value()); + swap(a.if_exists_ref().value(), b.if_exists_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void DropTagIndexReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t DropTagIndexReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t DropTagIndexReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t DropTagIndexReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void DropTagIndexReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t DropTagIndexReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t DropTagIndexReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t DropTagIndexReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::GetTagIndexReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::GetTagIndexReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +GetTagIndexReq::GetTagIndexReq(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, ::std::string index_name__arg) : + space_id(std::move(space_id__arg)), + index_name(std::move(index_name__arg)) { + __isset.space_id = true; + __isset.index_name = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void GetTagIndexReq::__clear() { + // clear all fields + space_id = 0; + index_name = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool GetTagIndexReq::operator==(const GetTagIndexReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return false; + } + if (!apache::thrift::StringTraits::isEqual(lhs.index_name, rhs.index_name)) { + return false; + } + return true; +} + +bool GetTagIndexReq::operator<(const GetTagIndexReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return lhs.space_id < rhs.space_id; + } + if (!apache::thrift::StringTraits::isEqual(lhs.index_name, rhs.index_name)) { + return apache::thrift::StringTraits::isLess(lhs.index_name, rhs.index_name); + } + return false; +} + + +void swap(GetTagIndexReq& a, GetTagIndexReq& b) { + using ::std::swap; + swap(a.space_id_ref().value(), b.space_id_ref().value()); + swap(a.index_name_ref().value(), b.index_name_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void GetTagIndexReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t GetTagIndexReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t GetTagIndexReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t GetTagIndexReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void GetTagIndexReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t GetTagIndexReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t GetTagIndexReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t GetTagIndexReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::GetTagIndexResp>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::GetTagIndexResp>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +GetTagIndexResp::GetTagIndexResp(apache::thrift::FragileConstructor, ::nebula::cpp2::ErrorCode code__arg, nebula::HostAddr leader__arg, ::nebula::meta::cpp2::IndexItem item__arg) : + code(std::move(code__arg)), + leader(std::move(leader__arg)), + item(std::move(item__arg)) { + __isset.code = true; + __isset.leader = true; + __isset.item = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void GetTagIndexResp::__clear() { + // clear all fields + code = ::nebula::cpp2::ErrorCode::SUCCEEDED; + leader.__clear(); + item.__clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool GetTagIndexResp::operator==(const GetTagIndexResp& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.code == rhs.code)) { + return false; + } + if (!(lhs.leader == rhs.leader)) { + return false; + } + if (!(lhs.item == rhs.item)) { + return false; + } + return true; +} + +bool GetTagIndexResp::operator<(const GetTagIndexResp& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.code == rhs.code)) { + return lhs.code < rhs.code; + } + if (!(lhs.leader == rhs.leader)) { + return lhs.leader < rhs.leader; + } + if (!(lhs.item == rhs.item)) { + return lhs.item < rhs.item; + } + return false; +} + +const nebula::HostAddr& GetTagIndexResp::get_leader() const& { + return leader; +} + +nebula::HostAddr GetTagIndexResp::get_leader() && { + return std::move(leader); +} + +const ::nebula::meta::cpp2::IndexItem& GetTagIndexResp::get_item() const& { + return item; +} + + ::nebula::meta::cpp2::IndexItem GetTagIndexResp::get_item() && { + return std::move(item); +} + + +void swap(GetTagIndexResp& a, GetTagIndexResp& b) { + using ::std::swap; + swap(a.code_ref().value(), b.code_ref().value()); + swap(a.leader_ref().value(), b.leader_ref().value()); + swap(a.item_ref().value(), b.item_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void GetTagIndexResp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t GetTagIndexResp::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t GetTagIndexResp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t GetTagIndexResp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void GetTagIndexResp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t GetTagIndexResp::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t GetTagIndexResp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t GetTagIndexResp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + GetTagIndexResp, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + GetTagIndexResp, + ::apache::thrift::type_class::structure, + ::nebula::meta::cpp2::IndexItem>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + GetTagIndexResp, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + GetTagIndexResp, + ::apache::thrift::type_class::structure, + ::nebula::meta::cpp2::IndexItem>, + "inconsistent use of nimble option"); + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::ListTagIndexesReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::ListTagIndexesReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +ListTagIndexesReq::ListTagIndexesReq(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg) : + space_id(std::move(space_id__arg)) { + __isset.space_id = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void ListTagIndexesReq::__clear() { + // clear all fields + space_id = 0; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool ListTagIndexesReq::operator==(const ListTagIndexesReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return false; + } + return true; +} + +bool ListTagIndexesReq::operator<(const ListTagIndexesReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return lhs.space_id < rhs.space_id; + } + return false; +} + + +void swap(ListTagIndexesReq& a, ListTagIndexesReq& b) { + using ::std::swap; + swap(a.space_id_ref().value(), b.space_id_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void ListTagIndexesReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t ListTagIndexesReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t ListTagIndexesReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t ListTagIndexesReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void ListTagIndexesReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t ListTagIndexesReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t ListTagIndexesReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t ListTagIndexesReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::ListTagIndexesResp>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::ListTagIndexesResp>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +ListTagIndexesResp::ListTagIndexesResp(apache::thrift::FragileConstructor, ::nebula::cpp2::ErrorCode code__arg, nebula::HostAddr leader__arg, ::std::vector< ::nebula::meta::cpp2::IndexItem> items__arg) : + code(std::move(code__arg)), + leader(std::move(leader__arg)), + items(std::move(items__arg)) { + __isset.code = true; + __isset.leader = true; + __isset.items = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void ListTagIndexesResp::__clear() { + // clear all fields + code = ::nebula::cpp2::ErrorCode::SUCCEEDED; + leader.__clear(); + items.clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool ListTagIndexesResp::operator==(const ListTagIndexesResp& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.code == rhs.code)) { + return false; + } + if (!(lhs.leader == rhs.leader)) { + return false; + } + if (!(lhs.items == rhs.items)) { + return false; + } + return true; +} + +bool ListTagIndexesResp::operator<(const ListTagIndexesResp& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.code == rhs.code)) { + return lhs.code < rhs.code; + } + if (!(lhs.leader == rhs.leader)) { + return lhs.leader < rhs.leader; + } + if (!(lhs.items == rhs.items)) { + return lhs.items < rhs.items; + } + return false; +} + +const nebula::HostAddr& ListTagIndexesResp::get_leader() const& { + return leader; +} + +nebula::HostAddr ListTagIndexesResp::get_leader() && { + return std::move(leader); +} + +const ::std::vector< ::nebula::meta::cpp2::IndexItem>& ListTagIndexesResp::get_items() const& { + return items; +} + +::std::vector< ::nebula::meta::cpp2::IndexItem> ListTagIndexesResp::get_items() && { + return std::move(items); +} + + +void swap(ListTagIndexesResp& a, ListTagIndexesResp& b) { + using ::std::swap; + swap(a.code_ref().value(), b.code_ref().value()); + swap(a.leader_ref().value(), b.leader_ref().value()); + swap(a.items_ref().value(), b.items_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void ListTagIndexesResp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t ListTagIndexesResp::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t ListTagIndexesResp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t ListTagIndexesResp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void ListTagIndexesResp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t ListTagIndexesResp::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t ListTagIndexesResp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t ListTagIndexesResp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + ListTagIndexesResp, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + ListTagIndexesResp, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector< ::nebula::meta::cpp2::IndexItem>>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + ListTagIndexesResp, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + ListTagIndexesResp, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector< ::nebula::meta::cpp2::IndexItem>>, + "inconsistent use of nimble option"); + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::CreateEdgeIndexReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::CreateEdgeIndexReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +CreateEdgeIndexReq::CreateEdgeIndexReq() : + space_id(0), + if_not_exists(0) {} +THRIFT_IGNORE_ISSET_USE_WARNING_END + + +CreateEdgeIndexReq::~CreateEdgeIndexReq() {} + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +CreateEdgeIndexReq::CreateEdgeIndexReq(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, ::std::string index_name__arg, ::std::string edge_name__arg, ::std::vector< ::nebula::meta::cpp2::IndexFieldDef> fields__arg, bool if_not_exists__arg, ::std::string comment__arg) : + space_id(std::move(space_id__arg)), + index_name(std::move(index_name__arg)), + edge_name(std::move(edge_name__arg)), + fields(std::move(fields__arg)), + if_not_exists(std::move(if_not_exists__arg)), + comment(std::move(comment__arg)) { + __isset.space_id = true; + __isset.index_name = true; + __isset.edge_name = true; + __isset.fields = true; + __isset.if_not_exists = true; + __isset.comment = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void CreateEdgeIndexReq::__clear() { + // clear all fields + space_id = 0; + index_name = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); + edge_name = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); + fields.clear(); + if_not_exists = 0; + comment = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool CreateEdgeIndexReq::operator==(const CreateEdgeIndexReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return false; + } + if (!apache::thrift::StringTraits::isEqual(lhs.index_name, rhs.index_name)) { + return false; + } + if (!apache::thrift::StringTraits::isEqual(lhs.edge_name, rhs.edge_name)) { + return false; + } + if (!(lhs.fields == rhs.fields)) { + return false; + } + if (!(lhs.if_not_exists == rhs.if_not_exists)) { + return false; + } + if (lhs.comment_ref().has_value() != rhs.comment_ref().has_value()) { + return false; + } + if (lhs.comment_ref().has_value()) { + if (!apache::thrift::StringTraits::isEqual(lhs.comment, rhs.comment)) { + return false; + } + } + return true; +} + +bool CreateEdgeIndexReq::operator<(const CreateEdgeIndexReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return lhs.space_id < rhs.space_id; + } + if (!apache::thrift::StringTraits::isEqual(lhs.index_name, rhs.index_name)) { + return apache::thrift::StringTraits::isLess(lhs.index_name, rhs.index_name); + } + if (!apache::thrift::StringTraits::isEqual(lhs.edge_name, rhs.edge_name)) { + return apache::thrift::StringTraits::isLess(lhs.edge_name, rhs.edge_name); + } + if (!(lhs.fields == rhs.fields)) { + return lhs.fields < rhs.fields; + } + if (!(lhs.if_not_exists == rhs.if_not_exists)) { + return lhs.if_not_exists < rhs.if_not_exists; + } + if (lhs.comment_ref().has_value() != rhs.comment_ref().has_value()) { + return lhs.comment_ref().has_value() < rhs.comment_ref().has_value(); + } + if (lhs.comment_ref().has_value()) { + if (!apache::thrift::StringTraits::isEqual(lhs.comment, rhs.comment)) { + return apache::thrift::StringTraits::isLess(lhs.comment, rhs.comment); + } + } + return false; +} + +const ::std::vector< ::nebula::meta::cpp2::IndexFieldDef>& CreateEdgeIndexReq::get_fields() const& { + return fields; +} + +::std::vector< ::nebula::meta::cpp2::IndexFieldDef> CreateEdgeIndexReq::get_fields() && { + return std::move(fields); +} + + +void swap(CreateEdgeIndexReq& a, CreateEdgeIndexReq& b) { + using ::std::swap; + swap(a.space_id_ref().value(), b.space_id_ref().value()); + swap(a.index_name_ref().value(), b.index_name_ref().value()); + swap(a.edge_name_ref().value(), b.edge_name_ref().value()); + swap(a.fields_ref().value(), b.fields_ref().value()); + swap(a.if_not_exists_ref().value(), b.if_not_exists_ref().value()); + swap(a.comment_ref().value_unchecked(), b.comment_ref().value_unchecked()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void CreateEdgeIndexReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t CreateEdgeIndexReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t CreateEdgeIndexReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t CreateEdgeIndexReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void CreateEdgeIndexReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t CreateEdgeIndexReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t CreateEdgeIndexReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t CreateEdgeIndexReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + CreateEdgeIndexReq, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector< ::nebula::meta::cpp2::IndexFieldDef>>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + CreateEdgeIndexReq, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector< ::nebula::meta::cpp2::IndexFieldDef>>, + "inconsistent use of nimble option"); + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::DropEdgeIndexReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::DropEdgeIndexReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +DropEdgeIndexReq::DropEdgeIndexReq(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, ::std::string index_name__arg, bool if_exists__arg) : + space_id(std::move(space_id__arg)), + index_name(std::move(index_name__arg)), + if_exists(std::move(if_exists__arg)) { + __isset.space_id = true; + __isset.index_name = true; + __isset.if_exists = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void DropEdgeIndexReq::__clear() { + // clear all fields + space_id = 0; + index_name = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); + if_exists = 0; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool DropEdgeIndexReq::operator==(const DropEdgeIndexReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return false; + } + if (!apache::thrift::StringTraits::isEqual(lhs.index_name, rhs.index_name)) { + return false; + } + if (!(lhs.if_exists == rhs.if_exists)) { + return false; + } + return true; +} + +bool DropEdgeIndexReq::operator<(const DropEdgeIndexReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return lhs.space_id < rhs.space_id; + } + if (!apache::thrift::StringTraits::isEqual(lhs.index_name, rhs.index_name)) { + return apache::thrift::StringTraits::isLess(lhs.index_name, rhs.index_name); + } + if (!(lhs.if_exists == rhs.if_exists)) { + return lhs.if_exists < rhs.if_exists; + } + return false; +} + + +void swap(DropEdgeIndexReq& a, DropEdgeIndexReq& b) { + using ::std::swap; + swap(a.space_id_ref().value(), b.space_id_ref().value()); + swap(a.index_name_ref().value(), b.index_name_ref().value()); + swap(a.if_exists_ref().value(), b.if_exists_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void DropEdgeIndexReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t DropEdgeIndexReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t DropEdgeIndexReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t DropEdgeIndexReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void DropEdgeIndexReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t DropEdgeIndexReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t DropEdgeIndexReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t DropEdgeIndexReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::GetEdgeIndexReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::GetEdgeIndexReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +GetEdgeIndexReq::GetEdgeIndexReq(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, ::std::string index_name__arg) : + space_id(std::move(space_id__arg)), + index_name(std::move(index_name__arg)) { + __isset.space_id = true; + __isset.index_name = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void GetEdgeIndexReq::__clear() { + // clear all fields + space_id = 0; + index_name = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool GetEdgeIndexReq::operator==(const GetEdgeIndexReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return false; + } + if (!apache::thrift::StringTraits::isEqual(lhs.index_name, rhs.index_name)) { + return false; + } + return true; +} + +bool GetEdgeIndexReq::operator<(const GetEdgeIndexReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return lhs.space_id < rhs.space_id; + } + if (!apache::thrift::StringTraits::isEqual(lhs.index_name, rhs.index_name)) { + return apache::thrift::StringTraits::isLess(lhs.index_name, rhs.index_name); + } + return false; +} + + +void swap(GetEdgeIndexReq& a, GetEdgeIndexReq& b) { + using ::std::swap; + swap(a.space_id_ref().value(), b.space_id_ref().value()); + swap(a.index_name_ref().value(), b.index_name_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void GetEdgeIndexReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t GetEdgeIndexReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t GetEdgeIndexReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t GetEdgeIndexReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void GetEdgeIndexReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t GetEdgeIndexReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t GetEdgeIndexReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t GetEdgeIndexReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::GetEdgeIndexResp>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::GetEdgeIndexResp>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +GetEdgeIndexResp::GetEdgeIndexResp(apache::thrift::FragileConstructor, ::nebula::cpp2::ErrorCode code__arg, nebula::HostAddr leader__arg, ::nebula::meta::cpp2::IndexItem item__arg) : + code(std::move(code__arg)), + leader(std::move(leader__arg)), + item(std::move(item__arg)) { + __isset.code = true; + __isset.leader = true; + __isset.item = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void GetEdgeIndexResp::__clear() { + // clear all fields + code = ::nebula::cpp2::ErrorCode::SUCCEEDED; + leader.__clear(); + item.__clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool GetEdgeIndexResp::operator==(const GetEdgeIndexResp& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.code == rhs.code)) { + return false; + } + if (!(lhs.leader == rhs.leader)) { + return false; + } + if (!(lhs.item == rhs.item)) { + return false; + } + return true; +} + +bool GetEdgeIndexResp::operator<(const GetEdgeIndexResp& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.code == rhs.code)) { + return lhs.code < rhs.code; + } + if (!(lhs.leader == rhs.leader)) { + return lhs.leader < rhs.leader; + } + if (!(lhs.item == rhs.item)) { + return lhs.item < rhs.item; + } + return false; +} + +const nebula::HostAddr& GetEdgeIndexResp::get_leader() const& { + return leader; +} + +nebula::HostAddr GetEdgeIndexResp::get_leader() && { + return std::move(leader); +} + +const ::nebula::meta::cpp2::IndexItem& GetEdgeIndexResp::get_item() const& { + return item; +} + + ::nebula::meta::cpp2::IndexItem GetEdgeIndexResp::get_item() && { + return std::move(item); +} + + +void swap(GetEdgeIndexResp& a, GetEdgeIndexResp& b) { + using ::std::swap; + swap(a.code_ref().value(), b.code_ref().value()); + swap(a.leader_ref().value(), b.leader_ref().value()); + swap(a.item_ref().value(), b.item_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void GetEdgeIndexResp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t GetEdgeIndexResp::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t GetEdgeIndexResp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t GetEdgeIndexResp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void GetEdgeIndexResp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t GetEdgeIndexResp::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t GetEdgeIndexResp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t GetEdgeIndexResp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + GetEdgeIndexResp, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + GetEdgeIndexResp, + ::apache::thrift::type_class::structure, + ::nebula::meta::cpp2::IndexItem>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + GetEdgeIndexResp, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + GetEdgeIndexResp, + ::apache::thrift::type_class::structure, + ::nebula::meta::cpp2::IndexItem>, + "inconsistent use of nimble option"); + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::ListEdgeIndexesReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::ListEdgeIndexesReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +ListEdgeIndexesReq::ListEdgeIndexesReq(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg) : + space_id(std::move(space_id__arg)) { + __isset.space_id = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void ListEdgeIndexesReq::__clear() { + // clear all fields + space_id = 0; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool ListEdgeIndexesReq::operator==(const ListEdgeIndexesReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return false; + } + return true; +} + +bool ListEdgeIndexesReq::operator<(const ListEdgeIndexesReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return lhs.space_id < rhs.space_id; + } + return false; +} + + +void swap(ListEdgeIndexesReq& a, ListEdgeIndexesReq& b) { + using ::std::swap; + swap(a.space_id_ref().value(), b.space_id_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void ListEdgeIndexesReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t ListEdgeIndexesReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t ListEdgeIndexesReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t ListEdgeIndexesReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void ListEdgeIndexesReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t ListEdgeIndexesReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t ListEdgeIndexesReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t ListEdgeIndexesReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::ListEdgeIndexesResp>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::ListEdgeIndexesResp>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +ListEdgeIndexesResp::ListEdgeIndexesResp(apache::thrift::FragileConstructor, ::nebula::cpp2::ErrorCode code__arg, nebula::HostAddr leader__arg, ::std::vector< ::nebula::meta::cpp2::IndexItem> items__arg) : + code(std::move(code__arg)), + leader(std::move(leader__arg)), + items(std::move(items__arg)) { + __isset.code = true; + __isset.leader = true; + __isset.items = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void ListEdgeIndexesResp::__clear() { + // clear all fields + code = ::nebula::cpp2::ErrorCode::SUCCEEDED; + leader.__clear(); + items.clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool ListEdgeIndexesResp::operator==(const ListEdgeIndexesResp& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.code == rhs.code)) { + return false; + } + if (!(lhs.leader == rhs.leader)) { + return false; + } + if (!(lhs.items == rhs.items)) { + return false; + } + return true; +} + +bool ListEdgeIndexesResp::operator<(const ListEdgeIndexesResp& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.code == rhs.code)) { + return lhs.code < rhs.code; + } + if (!(lhs.leader == rhs.leader)) { + return lhs.leader < rhs.leader; + } + if (!(lhs.items == rhs.items)) { + return lhs.items < rhs.items; + } + return false; +} + +const nebula::HostAddr& ListEdgeIndexesResp::get_leader() const& { + return leader; +} + +nebula::HostAddr ListEdgeIndexesResp::get_leader() && { + return std::move(leader); +} + +const ::std::vector< ::nebula::meta::cpp2::IndexItem>& ListEdgeIndexesResp::get_items() const& { + return items; +} + +::std::vector< ::nebula::meta::cpp2::IndexItem> ListEdgeIndexesResp::get_items() && { + return std::move(items); +} + + +void swap(ListEdgeIndexesResp& a, ListEdgeIndexesResp& b) { + using ::std::swap; + swap(a.code_ref().value(), b.code_ref().value()); + swap(a.leader_ref().value(), b.leader_ref().value()); + swap(a.items_ref().value(), b.items_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void ListEdgeIndexesResp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t ListEdgeIndexesResp::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t ListEdgeIndexesResp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t ListEdgeIndexesResp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void ListEdgeIndexesResp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t ListEdgeIndexesResp::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t ListEdgeIndexesResp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t ListEdgeIndexesResp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + ListEdgeIndexesResp, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + ListEdgeIndexesResp, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector< ::nebula::meta::cpp2::IndexItem>>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + ListEdgeIndexesResp, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + ListEdgeIndexesResp, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector< ::nebula::meta::cpp2::IndexItem>>, + "inconsistent use of nimble option"); + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::RebuildIndexReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::RebuildIndexReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +RebuildIndexReq::RebuildIndexReq(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, ::std::string index_name__arg) : + space_id(std::move(space_id__arg)), + index_name(std::move(index_name__arg)) { + __isset.space_id = true; + __isset.index_name = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void RebuildIndexReq::__clear() { + // clear all fields + space_id = 0; + index_name = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool RebuildIndexReq::operator==(const RebuildIndexReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return false; + } + if (!apache::thrift::StringTraits::isEqual(lhs.index_name, rhs.index_name)) { + return false; + } + return true; +} + +bool RebuildIndexReq::operator<(const RebuildIndexReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return lhs.space_id < rhs.space_id; + } + if (!apache::thrift::StringTraits::isEqual(lhs.index_name, rhs.index_name)) { + return apache::thrift::StringTraits::isLess(lhs.index_name, rhs.index_name); + } + return false; +} + + +void swap(RebuildIndexReq& a, RebuildIndexReq& b) { + using ::std::swap; + swap(a.space_id_ref().value(), b.space_id_ref().value()); + swap(a.index_name_ref().value(), b.index_name_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void RebuildIndexReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t RebuildIndexReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t RebuildIndexReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t RebuildIndexReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void RebuildIndexReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t RebuildIndexReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t RebuildIndexReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t RebuildIndexReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::CreateUserReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::CreateUserReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +CreateUserReq::CreateUserReq(apache::thrift::FragileConstructor, ::std::string account__arg, ::std::string encoded_pwd__arg, bool if_not_exists__arg) : + account(std::move(account__arg)), + encoded_pwd(std::move(encoded_pwd__arg)), + if_not_exists(std::move(if_not_exists__arg)) { + __isset.account = true; + __isset.encoded_pwd = true; + __isset.if_not_exists = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void CreateUserReq::__clear() { + // clear all fields + account = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); + encoded_pwd = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); + if_not_exists = 0; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool CreateUserReq::operator==(const CreateUserReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!apache::thrift::StringTraits::isEqual(lhs.account, rhs.account)) { + return false; + } + if (!apache::thrift::StringTraits::isEqual(lhs.encoded_pwd, rhs.encoded_pwd)) { + return false; + } + if (!(lhs.if_not_exists == rhs.if_not_exists)) { + return false; + } + return true; +} + +bool CreateUserReq::operator<(const CreateUserReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!apache::thrift::StringTraits::isEqual(lhs.account, rhs.account)) { + return apache::thrift::StringTraits::isLess(lhs.account, rhs.account); + } + if (!apache::thrift::StringTraits::isEqual(lhs.encoded_pwd, rhs.encoded_pwd)) { + return apache::thrift::StringTraits::isLess(lhs.encoded_pwd, rhs.encoded_pwd); + } + if (!(lhs.if_not_exists == rhs.if_not_exists)) { + return lhs.if_not_exists < rhs.if_not_exists; + } + return false; +} + + +void swap(CreateUserReq& a, CreateUserReq& b) { + using ::std::swap; + swap(a.account_ref().value(), b.account_ref().value()); + swap(a.encoded_pwd_ref().value(), b.encoded_pwd_ref().value()); + swap(a.if_not_exists_ref().value(), b.if_not_exists_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void CreateUserReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t CreateUserReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t CreateUserReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t CreateUserReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void CreateUserReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t CreateUserReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t CreateUserReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t CreateUserReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::DropUserReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::DropUserReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +DropUserReq::DropUserReq(apache::thrift::FragileConstructor, ::std::string account__arg, bool if_exists__arg) : + account(std::move(account__arg)), + if_exists(std::move(if_exists__arg)) { + __isset.account = true; + __isset.if_exists = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void DropUserReq::__clear() { + // clear all fields + account = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); + if_exists = 0; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool DropUserReq::operator==(const DropUserReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!apache::thrift::StringTraits::isEqual(lhs.account, rhs.account)) { + return false; + } + if (!(lhs.if_exists == rhs.if_exists)) { + return false; + } + return true; +} + +bool DropUserReq::operator<(const DropUserReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!apache::thrift::StringTraits::isEqual(lhs.account, rhs.account)) { + return apache::thrift::StringTraits::isLess(lhs.account, rhs.account); + } + if (!(lhs.if_exists == rhs.if_exists)) { + return lhs.if_exists < rhs.if_exists; + } + return false; +} + + +void swap(DropUserReq& a, DropUserReq& b) { + using ::std::swap; + swap(a.account_ref().value(), b.account_ref().value()); + swap(a.if_exists_ref().value(), b.if_exists_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void DropUserReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t DropUserReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t DropUserReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t DropUserReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void DropUserReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t DropUserReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t DropUserReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t DropUserReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::AlterUserReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::AlterUserReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +AlterUserReq::AlterUserReq(apache::thrift::FragileConstructor, ::std::string account__arg, ::std::string encoded_pwd__arg) : + account(std::move(account__arg)), + encoded_pwd(std::move(encoded_pwd__arg)) { + __isset.account = true; + __isset.encoded_pwd = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void AlterUserReq::__clear() { + // clear all fields + account = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); + encoded_pwd = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool AlterUserReq::operator==(const AlterUserReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!apache::thrift::StringTraits::isEqual(lhs.account, rhs.account)) { + return false; + } + if (!apache::thrift::StringTraits::isEqual(lhs.encoded_pwd, rhs.encoded_pwd)) { + return false; + } + return true; +} + +bool AlterUserReq::operator<(const AlterUserReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!apache::thrift::StringTraits::isEqual(lhs.account, rhs.account)) { + return apache::thrift::StringTraits::isLess(lhs.account, rhs.account); + } + if (!apache::thrift::StringTraits::isEqual(lhs.encoded_pwd, rhs.encoded_pwd)) { + return apache::thrift::StringTraits::isLess(lhs.encoded_pwd, rhs.encoded_pwd); + } + return false; +} + + +void swap(AlterUserReq& a, AlterUserReq& b) { + using ::std::swap; + swap(a.account_ref().value(), b.account_ref().value()); + swap(a.encoded_pwd_ref().value(), b.encoded_pwd_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void AlterUserReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t AlterUserReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t AlterUserReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t AlterUserReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void AlterUserReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t AlterUserReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t AlterUserReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t AlterUserReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::GrantRoleReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::GrantRoleReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +GrantRoleReq::GrantRoleReq(apache::thrift::FragileConstructor, ::nebula::meta::cpp2::RoleItem role_item__arg) : + role_item(std::move(role_item__arg)) { + __isset.role_item = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void GrantRoleReq::__clear() { + // clear all fields + role_item.__clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool GrantRoleReq::operator==(const GrantRoleReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.role_item == rhs.role_item)) { + return false; + } + return true; +} + +bool GrantRoleReq::operator<(const GrantRoleReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.role_item == rhs.role_item)) { + return lhs.role_item < rhs.role_item; + } + return false; +} + +const ::nebula::meta::cpp2::RoleItem& GrantRoleReq::get_role_item() const& { + return role_item; +} + + ::nebula::meta::cpp2::RoleItem GrantRoleReq::get_role_item() && { + return std::move(role_item); +} + + +void swap(GrantRoleReq& a, GrantRoleReq& b) { + using ::std::swap; + swap(a.role_item_ref().value(), b.role_item_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void GrantRoleReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t GrantRoleReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t GrantRoleReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t GrantRoleReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void GrantRoleReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t GrantRoleReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t GrantRoleReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t GrantRoleReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + GrantRoleReq, + ::apache::thrift::type_class::structure, + ::nebula::meta::cpp2::RoleItem>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + GrantRoleReq, + ::apache::thrift::type_class::structure, + ::nebula::meta::cpp2::RoleItem>, + "inconsistent use of nimble option"); + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::RevokeRoleReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::RevokeRoleReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +RevokeRoleReq::RevokeRoleReq(apache::thrift::FragileConstructor, ::nebula::meta::cpp2::RoleItem role_item__arg) : + role_item(std::move(role_item__arg)) { + __isset.role_item = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void RevokeRoleReq::__clear() { + // clear all fields + role_item.__clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool RevokeRoleReq::operator==(const RevokeRoleReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.role_item == rhs.role_item)) { + return false; + } + return true; +} + +bool RevokeRoleReq::operator<(const RevokeRoleReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.role_item == rhs.role_item)) { + return lhs.role_item < rhs.role_item; + } + return false; +} + +const ::nebula::meta::cpp2::RoleItem& RevokeRoleReq::get_role_item() const& { + return role_item; +} + + ::nebula::meta::cpp2::RoleItem RevokeRoleReq::get_role_item() && { + return std::move(role_item); +} + + +void swap(RevokeRoleReq& a, RevokeRoleReq& b) { + using ::std::swap; + swap(a.role_item_ref().value(), b.role_item_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void RevokeRoleReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t RevokeRoleReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t RevokeRoleReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t RevokeRoleReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void RevokeRoleReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t RevokeRoleReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t RevokeRoleReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t RevokeRoleReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + RevokeRoleReq, + ::apache::thrift::type_class::structure, + ::nebula::meta::cpp2::RoleItem>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + RevokeRoleReq, + ::apache::thrift::type_class::structure, + ::nebula::meta::cpp2::RoleItem>, + "inconsistent use of nimble option"); + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::ListUsersReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::ListUsersReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +ListUsersReq::ListUsersReq(apache::thrift::FragileConstructor) {} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void ListUsersReq::__clear() { + // clear all fields +} + +bool ListUsersReq::operator==(const ListUsersReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + return true; +} + +bool ListUsersReq::operator<(const ListUsersReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + return false; +} + + +void swap(ListUsersReq& a, ListUsersReq& b) { + using ::std::swap; + (void)a; + (void)b; +} + +template void ListUsersReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t ListUsersReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t ListUsersReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t ListUsersReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void ListUsersReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t ListUsersReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t ListUsersReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t ListUsersReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::ListUsersResp>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::ListUsersResp>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +ListUsersResp::ListUsersResp(apache::thrift::FragileConstructor, ::nebula::cpp2::ErrorCode code__arg, nebula::HostAddr leader__arg, std::unordered_map<::std::string, ::std::string> users__arg) : + code(std::move(code__arg)), + leader(std::move(leader__arg)), + users(std::move(users__arg)) { + __isset.code = true; + __isset.leader = true; + __isset.users = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void ListUsersResp::__clear() { + // clear all fields + code = ::nebula::cpp2::ErrorCode::SUCCEEDED; + leader.__clear(); + users.clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool ListUsersResp::operator==(const ListUsersResp& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.code == rhs.code)) { + return false; + } + if (!(lhs.leader == rhs.leader)) { + return false; + } + if (!(lhs.users == rhs.users)) { + return false; + } + return true; +} + +const nebula::HostAddr& ListUsersResp::get_leader() const& { + return leader; +} + +nebula::HostAddr ListUsersResp::get_leader() && { + return std::move(leader); +} + +const std::unordered_map<::std::string, ::std::string>& ListUsersResp::get_users() const& { + return users; +} + +std::unordered_map<::std::string, ::std::string> ListUsersResp::get_users() && { + return std::move(users); +} + + +void swap(ListUsersResp& a, ListUsersResp& b) { + using ::std::swap; + swap(a.code_ref().value(), b.code_ref().value()); + swap(a.leader_ref().value(), b.leader_ref().value()); + swap(a.users_ref().value(), b.users_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void ListUsersResp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t ListUsersResp::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t ListUsersResp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t ListUsersResp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void ListUsersResp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t ListUsersResp::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t ListUsersResp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t ListUsersResp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + ListUsersResp, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + ListUsersResp, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of nimble option"); + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::ListRolesReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::ListRolesReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +ListRolesReq::ListRolesReq(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg) : + space_id(std::move(space_id__arg)) { + __isset.space_id = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void ListRolesReq::__clear() { + // clear all fields + space_id = 0; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool ListRolesReq::operator==(const ListRolesReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return false; + } + return true; +} + +bool ListRolesReq::operator<(const ListRolesReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return lhs.space_id < rhs.space_id; + } + return false; +} + + +void swap(ListRolesReq& a, ListRolesReq& b) { + using ::std::swap; + swap(a.space_id_ref().value(), b.space_id_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void ListRolesReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t ListRolesReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t ListRolesReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t ListRolesReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void ListRolesReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t ListRolesReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t ListRolesReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t ListRolesReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::ListRolesResp>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::ListRolesResp>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +ListRolesResp::ListRolesResp(apache::thrift::FragileConstructor, ::nebula::cpp2::ErrorCode code__arg, nebula::HostAddr leader__arg, ::std::vector< ::nebula::meta::cpp2::RoleItem> roles__arg) : + code(std::move(code__arg)), + leader(std::move(leader__arg)), + roles(std::move(roles__arg)) { + __isset.code = true; + __isset.leader = true; + __isset.roles = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void ListRolesResp::__clear() { + // clear all fields + code = ::nebula::cpp2::ErrorCode::SUCCEEDED; + leader.__clear(); + roles.clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool ListRolesResp::operator==(const ListRolesResp& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.code == rhs.code)) { + return false; + } + if (!(lhs.leader == rhs.leader)) { + return false; + } + if (!(lhs.roles == rhs.roles)) { + return false; + } + return true; +} + +bool ListRolesResp::operator<(const ListRolesResp& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.code == rhs.code)) { + return lhs.code < rhs.code; + } + if (!(lhs.leader == rhs.leader)) { + return lhs.leader < rhs.leader; + } + if (!(lhs.roles == rhs.roles)) { + return lhs.roles < rhs.roles; + } + return false; +} + +const nebula::HostAddr& ListRolesResp::get_leader() const& { + return leader; +} + +nebula::HostAddr ListRolesResp::get_leader() && { + return std::move(leader); +} + +const ::std::vector< ::nebula::meta::cpp2::RoleItem>& ListRolesResp::get_roles() const& { + return roles; +} + +::std::vector< ::nebula::meta::cpp2::RoleItem> ListRolesResp::get_roles() && { + return std::move(roles); +} + + +void swap(ListRolesResp& a, ListRolesResp& b) { + using ::std::swap; + swap(a.code_ref().value(), b.code_ref().value()); + swap(a.leader_ref().value(), b.leader_ref().value()); + swap(a.roles_ref().value(), b.roles_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void ListRolesResp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t ListRolesResp::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t ListRolesResp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t ListRolesResp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void ListRolesResp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t ListRolesResp::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t ListRolesResp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t ListRolesResp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + ListRolesResp, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + ListRolesResp, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector< ::nebula::meta::cpp2::RoleItem>>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + ListRolesResp, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + ListRolesResp, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector< ::nebula::meta::cpp2::RoleItem>>, + "inconsistent use of nimble option"); + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::GetUserRolesReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::GetUserRolesReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +GetUserRolesReq::GetUserRolesReq(apache::thrift::FragileConstructor, ::std::string account__arg) : + account(std::move(account__arg)) { + __isset.account = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void GetUserRolesReq::__clear() { + // clear all fields + account = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool GetUserRolesReq::operator==(const GetUserRolesReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!apache::thrift::StringTraits::isEqual(lhs.account, rhs.account)) { + return false; + } + return true; +} + +bool GetUserRolesReq::operator<(const GetUserRolesReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!apache::thrift::StringTraits::isEqual(lhs.account, rhs.account)) { + return apache::thrift::StringTraits::isLess(lhs.account, rhs.account); + } + return false; +} + + +void swap(GetUserRolesReq& a, GetUserRolesReq& b) { + using ::std::swap; + swap(a.account_ref().value(), b.account_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void GetUserRolesReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t GetUserRolesReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t GetUserRolesReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t GetUserRolesReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void GetUserRolesReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t GetUserRolesReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t GetUserRolesReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t GetUserRolesReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::ChangePasswordReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::ChangePasswordReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +ChangePasswordReq::ChangePasswordReq(apache::thrift::FragileConstructor, ::std::string account__arg, ::std::string new_encoded_pwd__arg, ::std::string old_encoded_pwd__arg) : + account(std::move(account__arg)), + new_encoded_pwd(std::move(new_encoded_pwd__arg)), + old_encoded_pwd(std::move(old_encoded_pwd__arg)) { + __isset.account = true; + __isset.new_encoded_pwd = true; + __isset.old_encoded_pwd = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void ChangePasswordReq::__clear() { + // clear all fields + account = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); + new_encoded_pwd = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); + old_encoded_pwd = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool ChangePasswordReq::operator==(const ChangePasswordReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!apache::thrift::StringTraits::isEqual(lhs.account, rhs.account)) { + return false; + } + if (!apache::thrift::StringTraits::isEqual(lhs.new_encoded_pwd, rhs.new_encoded_pwd)) { + return false; + } + if (!apache::thrift::StringTraits::isEqual(lhs.old_encoded_pwd, rhs.old_encoded_pwd)) { + return false; + } + return true; +} + +bool ChangePasswordReq::operator<(const ChangePasswordReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!apache::thrift::StringTraits::isEqual(lhs.account, rhs.account)) { + return apache::thrift::StringTraits::isLess(lhs.account, rhs.account); + } + if (!apache::thrift::StringTraits::isEqual(lhs.new_encoded_pwd, rhs.new_encoded_pwd)) { + return apache::thrift::StringTraits::isLess(lhs.new_encoded_pwd, rhs.new_encoded_pwd); + } + if (!apache::thrift::StringTraits::isEqual(lhs.old_encoded_pwd, rhs.old_encoded_pwd)) { + return apache::thrift::StringTraits::isLess(lhs.old_encoded_pwd, rhs.old_encoded_pwd); + } + return false; +} + + +void swap(ChangePasswordReq& a, ChangePasswordReq& b) { + using ::std::swap; + swap(a.account_ref().value(), b.account_ref().value()); + swap(a.new_encoded_pwd_ref().value(), b.new_encoded_pwd_ref().value()); + swap(a.old_encoded_pwd_ref().value(), b.old_encoded_pwd_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void ChangePasswordReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t ChangePasswordReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t ChangePasswordReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t ChangePasswordReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void ChangePasswordReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t ChangePasswordReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t ChangePasswordReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t ChangePasswordReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::BalanceReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::BalanceReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +BalanceReq::BalanceReq() : + space_id(0), + id(0), + stop(0), + reset(0) {} +THRIFT_IGNORE_ISSET_USE_WARNING_END + + +BalanceReq::~BalanceReq() {} + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +BalanceReq::BalanceReq(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, int64_t id__arg, ::std::vector host_del__arg, bool stop__arg, bool reset__arg) : + space_id(std::move(space_id__arg)), + id(std::move(id__arg)), + host_del(std::move(host_del__arg)), + stop(std::move(stop__arg)), + reset(std::move(reset__arg)) { + __isset.space_id = true; + __isset.id = true; + __isset.host_del = true; + __isset.stop = true; + __isset.reset = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void BalanceReq::__clear() { + // clear all fields + space_id = 0; + id = 0; + host_del.clear(); + stop = 0; + reset = 0; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool BalanceReq::operator==(const BalanceReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (lhs.space_id_ref() != rhs.space_id_ref()) { + return false; + } + if (lhs.id_ref() != rhs.id_ref()) { + return false; + } + if (lhs.host_del_ref() != rhs.host_del_ref()) { + return false; + } + if (lhs.stop_ref() != rhs.stop_ref()) { + return false; + } + if (lhs.reset_ref() != rhs.reset_ref()) { + return false; + } + return true; +} + +bool BalanceReq::operator<(const BalanceReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (lhs.space_id_ref() != rhs.space_id_ref()) { + return lhs.space_id_ref() < rhs.space_id_ref(); + } + if (lhs.id_ref() != rhs.id_ref()) { + return lhs.id_ref() < rhs.id_ref(); + } + if (lhs.host_del_ref() != rhs.host_del_ref()) { + return lhs.host_del_ref() < rhs.host_del_ref(); + } + if (lhs.stop_ref() != rhs.stop_ref()) { + return lhs.stop_ref() < rhs.stop_ref(); + } + if (lhs.reset_ref() != rhs.reset_ref()) { + return lhs.reset_ref() < rhs.reset_ref(); + } + return false; +} + +const ::std::vector* BalanceReq::get_host_del() const& { + return host_del_ref().has_value() ? std::addressof(host_del) : nullptr; +} + +::std::vector* BalanceReq::get_host_del() & { + return host_del_ref().has_value() ? std::addressof(host_del) : nullptr; +} + + +void swap(BalanceReq& a, BalanceReq& b) { + using ::std::swap; + swap(a.space_id_ref().value_unchecked(), b.space_id_ref().value_unchecked()); + swap(a.id_ref().value_unchecked(), b.id_ref().value_unchecked()); + swap(a.host_del_ref().value_unchecked(), b.host_del_ref().value_unchecked()); + swap(a.stop_ref().value_unchecked(), b.stop_ref().value_unchecked()); + swap(a.reset_ref().value_unchecked(), b.reset_ref().value_unchecked()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void BalanceReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t BalanceReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t BalanceReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t BalanceReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void BalanceReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t BalanceReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t BalanceReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t BalanceReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + BalanceReq, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + BalanceReq, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector>, + "inconsistent use of nimble option"); + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::BalanceTask>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::BalanceTask>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +BalanceTask::BalanceTask(apache::thrift::FragileConstructor, ::std::string id__arg, ::nebula::meta::cpp2::TaskResult result__arg) : + id(std::move(id__arg)), + result(std::move(result__arg)) { + __isset.id = true; + __isset.result = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void BalanceTask::__clear() { + // clear all fields + id = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); + result = ::nebula::meta::cpp2::TaskResult::SUCCEEDED; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool BalanceTask::operator==(const BalanceTask& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!apache::thrift::StringTraits::isEqual(lhs.id, rhs.id)) { + return false; + } + if (!(lhs.result == rhs.result)) { + return false; + } + return true; +} + +bool BalanceTask::operator<(const BalanceTask& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!apache::thrift::StringTraits::isEqual(lhs.id, rhs.id)) { + return apache::thrift::StringTraits::isLess(lhs.id, rhs.id); + } + if (!(lhs.result == rhs.result)) { + return lhs.result < rhs.result; + } + return false; +} + + +void swap(BalanceTask& a, BalanceTask& b) { + using ::std::swap; + swap(a.id_ref().value(), b.id_ref().value()); + swap(a.result_ref().value(), b.result_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void BalanceTask::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t BalanceTask::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t BalanceTask::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t BalanceTask::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void BalanceTask::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t BalanceTask::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t BalanceTask::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t BalanceTask::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::BalanceResp>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::BalanceResp>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +BalanceResp::BalanceResp(apache::thrift::FragileConstructor, ::nebula::cpp2::ErrorCode code__arg, int64_t id__arg, nebula::HostAddr leader__arg, ::std::vector< ::nebula::meta::cpp2::BalanceTask> tasks__arg) : + code(std::move(code__arg)), + id(std::move(id__arg)), + leader(std::move(leader__arg)), + tasks(std::move(tasks__arg)) { + __isset.code = true; + __isset.id = true; + __isset.leader = true; + __isset.tasks = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void BalanceResp::__clear() { + // clear all fields + code = ::nebula::cpp2::ErrorCode::SUCCEEDED; + id = 0; + leader.__clear(); + tasks.clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool BalanceResp::operator==(const BalanceResp& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.code == rhs.code)) { + return false; + } + if (!(lhs.id == rhs.id)) { + return false; + } + if (!(lhs.leader == rhs.leader)) { + return false; + } + if (!(lhs.tasks == rhs.tasks)) { + return false; + } + return true; +} + +bool BalanceResp::operator<(const BalanceResp& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.code == rhs.code)) { + return lhs.code < rhs.code; + } + if (!(lhs.id == rhs.id)) { + return lhs.id < rhs.id; + } + if (!(lhs.leader == rhs.leader)) { + return lhs.leader < rhs.leader; + } + if (!(lhs.tasks == rhs.tasks)) { + return lhs.tasks < rhs.tasks; + } + return false; +} + +const nebula::HostAddr& BalanceResp::get_leader() const& { + return leader; +} + +nebula::HostAddr BalanceResp::get_leader() && { + return std::move(leader); +} + +const ::std::vector< ::nebula::meta::cpp2::BalanceTask>& BalanceResp::get_tasks() const& { + return tasks; +} + +::std::vector< ::nebula::meta::cpp2::BalanceTask> BalanceResp::get_tasks() && { + return std::move(tasks); +} + + +void swap(BalanceResp& a, BalanceResp& b) { + using ::std::swap; + swap(a.code_ref().value(), b.code_ref().value()); + swap(a.id_ref().value(), b.id_ref().value()); + swap(a.leader_ref().value(), b.leader_ref().value()); + swap(a.tasks_ref().value(), b.tasks_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void BalanceResp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t BalanceResp::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t BalanceResp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t BalanceResp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void BalanceResp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t BalanceResp::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t BalanceResp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t BalanceResp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + BalanceResp, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + BalanceResp, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector< ::nebula::meta::cpp2::BalanceTask>>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + BalanceResp, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + BalanceResp, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector< ::nebula::meta::cpp2::BalanceTask>>, + "inconsistent use of nimble option"); + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::LeaderBalanceReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::LeaderBalanceReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +LeaderBalanceReq::LeaderBalanceReq(apache::thrift::FragileConstructor) {} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void LeaderBalanceReq::__clear() { + // clear all fields +} + +bool LeaderBalanceReq::operator==(const LeaderBalanceReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + return true; +} + +bool LeaderBalanceReq::operator<(const LeaderBalanceReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + return false; +} + + +void swap(LeaderBalanceReq& a, LeaderBalanceReq& b) { + using ::std::swap; + (void)a; + (void)b; +} + +template void LeaderBalanceReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t LeaderBalanceReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t LeaderBalanceReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t LeaderBalanceReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void LeaderBalanceReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t LeaderBalanceReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t LeaderBalanceReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t LeaderBalanceReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::ConfigItem>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::ConfigItem>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +ConfigItem::ConfigItem(apache::thrift::FragileConstructor, ::nebula::meta::cpp2::ConfigModule module__arg, ::std::string name__arg, ::nebula::meta::cpp2::ConfigMode mode__arg, nebula::Value value__arg) : + module(std::move(module__arg)), + name(std::move(name__arg)), + mode(std::move(mode__arg)), + value(std::move(value__arg)) { + __isset.module = true; + __isset.name = true; + __isset.mode = true; + __isset.value = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void ConfigItem::__clear() { + // clear all fields + module = ::nebula::meta::cpp2::ConfigModule::UNKNOWN; + name = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); + mode = ::nebula::meta::cpp2::ConfigMode::IMMUTABLE; + value.__clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool ConfigItem::operator==(const ConfigItem& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.module == rhs.module)) { + return false; + } + if (!apache::thrift::StringTraits::isEqual(lhs.name, rhs.name)) { + return false; + } + if (!(lhs.mode == rhs.mode)) { + return false; + } + if (!(lhs.value == rhs.value)) { + return false; + } + return true; +} + +const nebula::Value& ConfigItem::get_value() const& { + return value; +} + +nebula::Value ConfigItem::get_value() && { + return std::move(value); +} + + +void swap(ConfigItem& a, ConfigItem& b) { + using ::std::swap; + swap(a.module_ref().value(), b.module_ref().value()); + swap(a.name_ref().value(), b.name_ref().value()); + swap(a.mode_ref().value(), b.mode_ref().value()); + swap(a.value_ref().value(), b.value_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void ConfigItem::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t ConfigItem::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t ConfigItem::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t ConfigItem::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void ConfigItem::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t ConfigItem::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t ConfigItem::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t ConfigItem::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + ConfigItem, + ::apache::thrift::type_class::variant, + nebula::Value>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + ConfigItem, + ::apache::thrift::type_class::variant, + nebula::Value>, + "inconsistent use of nimble option"); + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::RegConfigReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::RegConfigReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +RegConfigReq::RegConfigReq(apache::thrift::FragileConstructor, ::std::vector< ::nebula::meta::cpp2::ConfigItem> items__arg) : + items(std::move(items__arg)) { + __isset.items = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void RegConfigReq::__clear() { + // clear all fields + items.clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool RegConfigReq::operator==(const RegConfigReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.items == rhs.items)) { + return false; + } + return true; +} + +const ::std::vector< ::nebula::meta::cpp2::ConfigItem>& RegConfigReq::get_items() const& { + return items; +} + +::std::vector< ::nebula::meta::cpp2::ConfigItem> RegConfigReq::get_items() && { + return std::move(items); +} + + +void swap(RegConfigReq& a, RegConfigReq& b) { + using ::std::swap; + swap(a.items_ref().value(), b.items_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void RegConfigReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t RegConfigReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t RegConfigReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t RegConfigReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void RegConfigReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t RegConfigReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t RegConfigReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t RegConfigReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + RegConfigReq, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector< ::nebula::meta::cpp2::ConfigItem>>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + RegConfigReq, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector< ::nebula::meta::cpp2::ConfigItem>>, + "inconsistent use of nimble option"); + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::GetConfigReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::GetConfigReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +GetConfigReq::GetConfigReq(apache::thrift::FragileConstructor, ::nebula::meta::cpp2::ConfigItem item__arg) : + item(std::move(item__arg)) { + __isset.item = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void GetConfigReq::__clear() { + // clear all fields + item.__clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool GetConfigReq::operator==(const GetConfigReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.item == rhs.item)) { + return false; + } + return true; +} + +const ::nebula::meta::cpp2::ConfigItem& GetConfigReq::get_item() const& { + return item; +} + + ::nebula::meta::cpp2::ConfigItem GetConfigReq::get_item() && { + return std::move(item); +} + + +void swap(GetConfigReq& a, GetConfigReq& b) { + using ::std::swap; + swap(a.item_ref().value(), b.item_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void GetConfigReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t GetConfigReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t GetConfigReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t GetConfigReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void GetConfigReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t GetConfigReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t GetConfigReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t GetConfigReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + GetConfigReq, + ::apache::thrift::type_class::structure, + ::nebula::meta::cpp2::ConfigItem>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + GetConfigReq, + ::apache::thrift::type_class::structure, + ::nebula::meta::cpp2::ConfigItem>, + "inconsistent use of nimble option"); + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::GetConfigResp>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::GetConfigResp>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +GetConfigResp::GetConfigResp(apache::thrift::FragileConstructor, ::nebula::cpp2::ErrorCode code__arg, nebula::HostAddr leader__arg, ::std::vector< ::nebula::meta::cpp2::ConfigItem> items__arg) : + code(std::move(code__arg)), + leader(std::move(leader__arg)), + items(std::move(items__arg)) { + __isset.code = true; + __isset.leader = true; + __isset.items = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void GetConfigResp::__clear() { + // clear all fields + code = ::nebula::cpp2::ErrorCode::SUCCEEDED; + leader.__clear(); + items.clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool GetConfigResp::operator==(const GetConfigResp& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.code == rhs.code)) { + return false; + } + if (!(lhs.leader == rhs.leader)) { + return false; + } + if (!(lhs.items == rhs.items)) { + return false; + } + return true; +} + +const nebula::HostAddr& GetConfigResp::get_leader() const& { + return leader; +} + +nebula::HostAddr GetConfigResp::get_leader() && { + return std::move(leader); +} + +const ::std::vector< ::nebula::meta::cpp2::ConfigItem>& GetConfigResp::get_items() const& { + return items; +} + +::std::vector< ::nebula::meta::cpp2::ConfigItem> GetConfigResp::get_items() && { + return std::move(items); +} + + +void swap(GetConfigResp& a, GetConfigResp& b) { + using ::std::swap; + swap(a.code_ref().value(), b.code_ref().value()); + swap(a.leader_ref().value(), b.leader_ref().value()); + swap(a.items_ref().value(), b.items_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void GetConfigResp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t GetConfigResp::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t GetConfigResp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t GetConfigResp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void GetConfigResp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t GetConfigResp::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t GetConfigResp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t GetConfigResp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + GetConfigResp, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + GetConfigResp, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector< ::nebula::meta::cpp2::ConfigItem>>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + GetConfigResp, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + GetConfigResp, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector< ::nebula::meta::cpp2::ConfigItem>>, + "inconsistent use of nimble option"); + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::SetConfigReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::SetConfigReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +SetConfigReq::SetConfigReq(apache::thrift::FragileConstructor, ::nebula::meta::cpp2::ConfigItem item__arg) : + item(std::move(item__arg)) { + __isset.item = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void SetConfigReq::__clear() { + // clear all fields + item.__clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool SetConfigReq::operator==(const SetConfigReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.item == rhs.item)) { + return false; + } + return true; +} + +const ::nebula::meta::cpp2::ConfigItem& SetConfigReq::get_item() const& { + return item; +} + + ::nebula::meta::cpp2::ConfigItem SetConfigReq::get_item() && { + return std::move(item); +} + + +void swap(SetConfigReq& a, SetConfigReq& b) { + using ::std::swap; + swap(a.item_ref().value(), b.item_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void SetConfigReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t SetConfigReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t SetConfigReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t SetConfigReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void SetConfigReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t SetConfigReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t SetConfigReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t SetConfigReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + SetConfigReq, + ::apache::thrift::type_class::structure, + ::nebula::meta::cpp2::ConfigItem>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + SetConfigReq, + ::apache::thrift::type_class::structure, + ::nebula::meta::cpp2::ConfigItem>, + "inconsistent use of nimble option"); + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::ListConfigsReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::ListConfigsReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +ListConfigsReq::ListConfigsReq(apache::thrift::FragileConstructor, ::std::string space__arg, ::nebula::meta::cpp2::ConfigModule module__arg) : + space(std::move(space__arg)), + module(std::move(module__arg)) { + __isset.space = true; + __isset.module = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void ListConfigsReq::__clear() { + // clear all fields + space = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); + module = ::nebula::meta::cpp2::ConfigModule::UNKNOWN; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool ListConfigsReq::operator==(const ListConfigsReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!apache::thrift::StringTraits::isEqual(lhs.space, rhs.space)) { + return false; + } + if (!(lhs.module == rhs.module)) { + return false; + } + return true; +} + +bool ListConfigsReq::operator<(const ListConfigsReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!apache::thrift::StringTraits::isEqual(lhs.space, rhs.space)) { + return apache::thrift::StringTraits::isLess(lhs.space, rhs.space); + } + if (!(lhs.module == rhs.module)) { + return lhs.module < rhs.module; + } + return false; +} + + +void swap(ListConfigsReq& a, ListConfigsReq& b) { + using ::std::swap; + swap(a.space_ref().value(), b.space_ref().value()); + swap(a.module_ref().value(), b.module_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void ListConfigsReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t ListConfigsReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t ListConfigsReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t ListConfigsReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void ListConfigsReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t ListConfigsReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t ListConfigsReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t ListConfigsReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::ListConfigsResp>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::ListConfigsResp>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +ListConfigsResp::ListConfigsResp(apache::thrift::FragileConstructor, ::nebula::cpp2::ErrorCode code__arg, nebula::HostAddr leader__arg, ::std::vector< ::nebula::meta::cpp2::ConfigItem> items__arg) : + code(std::move(code__arg)), + leader(std::move(leader__arg)), + items(std::move(items__arg)) { + __isset.code = true; + __isset.leader = true; + __isset.items = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void ListConfigsResp::__clear() { + // clear all fields + code = ::nebula::cpp2::ErrorCode::SUCCEEDED; + leader.__clear(); + items.clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool ListConfigsResp::operator==(const ListConfigsResp& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.code == rhs.code)) { + return false; + } + if (!(lhs.leader == rhs.leader)) { + return false; + } + if (!(lhs.items == rhs.items)) { + return false; + } + return true; +} + +const nebula::HostAddr& ListConfigsResp::get_leader() const& { + return leader; +} + +nebula::HostAddr ListConfigsResp::get_leader() && { + return std::move(leader); +} + +const ::std::vector< ::nebula::meta::cpp2::ConfigItem>& ListConfigsResp::get_items() const& { + return items; +} + +::std::vector< ::nebula::meta::cpp2::ConfigItem> ListConfigsResp::get_items() && { + return std::move(items); +} + + +void swap(ListConfigsResp& a, ListConfigsResp& b) { + using ::std::swap; + swap(a.code_ref().value(), b.code_ref().value()); + swap(a.leader_ref().value(), b.leader_ref().value()); + swap(a.items_ref().value(), b.items_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void ListConfigsResp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t ListConfigsResp::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t ListConfigsResp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t ListConfigsResp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void ListConfigsResp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t ListConfigsResp::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t ListConfigsResp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t ListConfigsResp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + ListConfigsResp, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + ListConfigsResp, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector< ::nebula::meta::cpp2::ConfigItem>>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + ListConfigsResp, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + ListConfigsResp, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector< ::nebula::meta::cpp2::ConfigItem>>, + "inconsistent use of nimble option"); + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::CreateSnapshotReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::CreateSnapshotReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +CreateSnapshotReq::CreateSnapshotReq(apache::thrift::FragileConstructor) {} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void CreateSnapshotReq::__clear() { + // clear all fields +} + +bool CreateSnapshotReq::operator==(const CreateSnapshotReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + return true; +} + +bool CreateSnapshotReq::operator<(const CreateSnapshotReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + return false; +} + + +void swap(CreateSnapshotReq& a, CreateSnapshotReq& b) { + using ::std::swap; + (void)a; + (void)b; +} + +template void CreateSnapshotReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t CreateSnapshotReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t CreateSnapshotReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t CreateSnapshotReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void CreateSnapshotReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t CreateSnapshotReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t CreateSnapshotReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t CreateSnapshotReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::DropSnapshotReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::DropSnapshotReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +DropSnapshotReq::DropSnapshotReq(apache::thrift::FragileConstructor, ::std::string name__arg) : + name(std::move(name__arg)) { + __isset.name = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void DropSnapshotReq::__clear() { + // clear all fields + name = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool DropSnapshotReq::operator==(const DropSnapshotReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!apache::thrift::StringTraits::isEqual(lhs.name, rhs.name)) { + return false; + } + return true; +} + +bool DropSnapshotReq::operator<(const DropSnapshotReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!apache::thrift::StringTraits::isEqual(lhs.name, rhs.name)) { + return apache::thrift::StringTraits::isLess(lhs.name, rhs.name); + } + return false; +} + + +void swap(DropSnapshotReq& a, DropSnapshotReq& b) { + using ::std::swap; + swap(a.name_ref().value(), b.name_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void DropSnapshotReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t DropSnapshotReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t DropSnapshotReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t DropSnapshotReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void DropSnapshotReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t DropSnapshotReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t DropSnapshotReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t DropSnapshotReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::ListSnapshotsReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::ListSnapshotsReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +ListSnapshotsReq::ListSnapshotsReq(apache::thrift::FragileConstructor) {} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void ListSnapshotsReq::__clear() { + // clear all fields +} + +bool ListSnapshotsReq::operator==(const ListSnapshotsReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + return true; +} + +bool ListSnapshotsReq::operator<(const ListSnapshotsReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + return false; +} + + +void swap(ListSnapshotsReq& a, ListSnapshotsReq& b) { + using ::std::swap; + (void)a; + (void)b; +} + +template void ListSnapshotsReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t ListSnapshotsReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t ListSnapshotsReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t ListSnapshotsReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void ListSnapshotsReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t ListSnapshotsReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t ListSnapshotsReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t ListSnapshotsReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::Snapshot>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::Snapshot>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +Snapshot::Snapshot(apache::thrift::FragileConstructor, ::std::string name__arg, ::nebula::meta::cpp2::SnapshotStatus status__arg, ::std::string hosts__arg) : + name(std::move(name__arg)), + status(std::move(status__arg)), + hosts(std::move(hosts__arg)) { + __isset.name = true; + __isset.status = true; + __isset.hosts = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void Snapshot::__clear() { + // clear all fields + name = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); + status = ::nebula::meta::cpp2::SnapshotStatus::VALID; + hosts = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool Snapshot::operator==(const Snapshot& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!apache::thrift::StringTraits::isEqual(lhs.name, rhs.name)) { + return false; + } + if (!(lhs.status == rhs.status)) { + return false; + } + if (!apache::thrift::StringTraits::isEqual(lhs.hosts, rhs.hosts)) { + return false; + } + return true; +} + +bool Snapshot::operator<(const Snapshot& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!apache::thrift::StringTraits::isEqual(lhs.name, rhs.name)) { + return apache::thrift::StringTraits::isLess(lhs.name, rhs.name); + } + if (!(lhs.status == rhs.status)) { + return lhs.status < rhs.status; + } + if (!apache::thrift::StringTraits::isEqual(lhs.hosts, rhs.hosts)) { + return apache::thrift::StringTraits::isLess(lhs.hosts, rhs.hosts); + } + return false; +} + + +void swap(Snapshot& a, Snapshot& b) { + using ::std::swap; + swap(a.name_ref().value(), b.name_ref().value()); + swap(a.status_ref().value(), b.status_ref().value()); + swap(a.hosts_ref().value(), b.hosts_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void Snapshot::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t Snapshot::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t Snapshot::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t Snapshot::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void Snapshot::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t Snapshot::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t Snapshot::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t Snapshot::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::ListSnapshotsResp>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::ListSnapshotsResp>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +ListSnapshotsResp::ListSnapshotsResp(apache::thrift::FragileConstructor, ::nebula::cpp2::ErrorCode code__arg, nebula::HostAddr leader__arg, ::std::vector< ::nebula::meta::cpp2::Snapshot> snapshots__arg) : + code(std::move(code__arg)), + leader(std::move(leader__arg)), + snapshots(std::move(snapshots__arg)) { + __isset.code = true; + __isset.leader = true; + __isset.snapshots = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void ListSnapshotsResp::__clear() { + // clear all fields + code = ::nebula::cpp2::ErrorCode::SUCCEEDED; + leader.__clear(); + snapshots.clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool ListSnapshotsResp::operator==(const ListSnapshotsResp& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.code == rhs.code)) { + return false; + } + if (!(lhs.leader == rhs.leader)) { + return false; + } + if (!(lhs.snapshots == rhs.snapshots)) { + return false; + } + return true; +} + +bool ListSnapshotsResp::operator<(const ListSnapshotsResp& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.code == rhs.code)) { + return lhs.code < rhs.code; + } + if (!(lhs.leader == rhs.leader)) { + return lhs.leader < rhs.leader; + } + if (!(lhs.snapshots == rhs.snapshots)) { + return lhs.snapshots < rhs.snapshots; + } + return false; +} + +const nebula::HostAddr& ListSnapshotsResp::get_leader() const& { + return leader; +} + +nebula::HostAddr ListSnapshotsResp::get_leader() && { + return std::move(leader); +} + +const ::std::vector< ::nebula::meta::cpp2::Snapshot>& ListSnapshotsResp::get_snapshots() const& { + return snapshots; +} + +::std::vector< ::nebula::meta::cpp2::Snapshot> ListSnapshotsResp::get_snapshots() && { + return std::move(snapshots); +} + + +void swap(ListSnapshotsResp& a, ListSnapshotsResp& b) { + using ::std::swap; + swap(a.code_ref().value(), b.code_ref().value()); + swap(a.leader_ref().value(), b.leader_ref().value()); + swap(a.snapshots_ref().value(), b.snapshots_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void ListSnapshotsResp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t ListSnapshotsResp::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t ListSnapshotsResp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t ListSnapshotsResp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void ListSnapshotsResp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t ListSnapshotsResp::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t ListSnapshotsResp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t ListSnapshotsResp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + ListSnapshotsResp, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + ListSnapshotsResp, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector< ::nebula::meta::cpp2::Snapshot>>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + ListSnapshotsResp, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + ListSnapshotsResp, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector< ::nebula::meta::cpp2::Snapshot>>, + "inconsistent use of nimble option"); + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::ListIndexStatusReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::ListIndexStatusReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +ListIndexStatusReq::ListIndexStatusReq(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg) : + space_id(std::move(space_id__arg)) { + __isset.space_id = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void ListIndexStatusReq::__clear() { + // clear all fields + space_id = 0; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool ListIndexStatusReq::operator==(const ListIndexStatusReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return false; + } + return true; +} + +bool ListIndexStatusReq::operator<(const ListIndexStatusReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return lhs.space_id < rhs.space_id; + } + return false; +} + + +void swap(ListIndexStatusReq& a, ListIndexStatusReq& b) { + using ::std::swap; + swap(a.space_id_ref().value(), b.space_id_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void ListIndexStatusReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t ListIndexStatusReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t ListIndexStatusReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t ListIndexStatusReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void ListIndexStatusReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t ListIndexStatusReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t ListIndexStatusReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t ListIndexStatusReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::IndexStatus>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::IndexStatus>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +IndexStatus::IndexStatus(apache::thrift::FragileConstructor, ::std::string name__arg, ::std::string status__arg) : + name(std::move(name__arg)), + status(std::move(status__arg)) { + __isset.name = true; + __isset.status = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void IndexStatus::__clear() { + // clear all fields + name = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); + status = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool IndexStatus::operator==(const IndexStatus& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!apache::thrift::StringTraits::isEqual(lhs.name, rhs.name)) { + return false; + } + if (!apache::thrift::StringTraits::isEqual(lhs.status, rhs.status)) { + return false; + } + return true; +} + +bool IndexStatus::operator<(const IndexStatus& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!apache::thrift::StringTraits::isEqual(lhs.name, rhs.name)) { + return apache::thrift::StringTraits::isLess(lhs.name, rhs.name); + } + if (!apache::thrift::StringTraits::isEqual(lhs.status, rhs.status)) { + return apache::thrift::StringTraits::isLess(lhs.status, rhs.status); + } + return false; +} + + +void swap(IndexStatus& a, IndexStatus& b) { + using ::std::swap; + swap(a.name_ref().value(), b.name_ref().value()); + swap(a.status_ref().value(), b.status_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void IndexStatus::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t IndexStatus::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t IndexStatus::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t IndexStatus::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void IndexStatus::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t IndexStatus::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t IndexStatus::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t IndexStatus::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::ListIndexStatusResp>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::ListIndexStatusResp>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +ListIndexStatusResp::ListIndexStatusResp(apache::thrift::FragileConstructor, ::nebula::cpp2::ErrorCode code__arg, nebula::HostAddr leader__arg, ::std::vector< ::nebula::meta::cpp2::IndexStatus> statuses__arg) : + code(std::move(code__arg)), + leader(std::move(leader__arg)), + statuses(std::move(statuses__arg)) { + __isset.code = true; + __isset.leader = true; + __isset.statuses = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void ListIndexStatusResp::__clear() { + // clear all fields + code = ::nebula::cpp2::ErrorCode::SUCCEEDED; + leader.__clear(); + statuses.clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool ListIndexStatusResp::operator==(const ListIndexStatusResp& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.code == rhs.code)) { + return false; + } + if (!(lhs.leader == rhs.leader)) { + return false; + } + if (!(lhs.statuses == rhs.statuses)) { + return false; + } + return true; +} + +bool ListIndexStatusResp::operator<(const ListIndexStatusResp& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.code == rhs.code)) { + return lhs.code < rhs.code; + } + if (!(lhs.leader == rhs.leader)) { + return lhs.leader < rhs.leader; + } + if (!(lhs.statuses == rhs.statuses)) { + return lhs.statuses < rhs.statuses; + } + return false; +} + +const nebula::HostAddr& ListIndexStatusResp::get_leader() const& { + return leader; +} + +nebula::HostAddr ListIndexStatusResp::get_leader() && { + return std::move(leader); +} + +const ::std::vector< ::nebula::meta::cpp2::IndexStatus>& ListIndexStatusResp::get_statuses() const& { + return statuses; +} + +::std::vector< ::nebula::meta::cpp2::IndexStatus> ListIndexStatusResp::get_statuses() && { + return std::move(statuses); +} + + +void swap(ListIndexStatusResp& a, ListIndexStatusResp& b) { + using ::std::swap; + swap(a.code_ref().value(), b.code_ref().value()); + swap(a.leader_ref().value(), b.leader_ref().value()); + swap(a.statuses_ref().value(), b.statuses_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void ListIndexStatusResp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t ListIndexStatusResp::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t ListIndexStatusResp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t ListIndexStatusResp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void ListIndexStatusResp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t ListIndexStatusResp::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t ListIndexStatusResp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t ListIndexStatusResp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + ListIndexStatusResp, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + ListIndexStatusResp, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector< ::nebula::meta::cpp2::IndexStatus>>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + ListIndexStatusResp, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + ListIndexStatusResp, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector< ::nebula::meta::cpp2::IndexStatus>>, + "inconsistent use of nimble option"); + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::AddZoneReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::AddZoneReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +AddZoneReq::AddZoneReq(apache::thrift::FragileConstructor, ::std::string zone_name__arg, ::std::vector nodes__arg) : + zone_name(std::move(zone_name__arg)), + nodes(std::move(nodes__arg)) { + __isset.zone_name = true; + __isset.nodes = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void AddZoneReq::__clear() { + // clear all fields + zone_name = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); + nodes.clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool AddZoneReq::operator==(const AddZoneReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!apache::thrift::StringTraits::isEqual(lhs.zone_name, rhs.zone_name)) { + return false; + } + if (!(lhs.nodes == rhs.nodes)) { + return false; + } + return true; +} + +bool AddZoneReq::operator<(const AddZoneReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!apache::thrift::StringTraits::isEqual(lhs.zone_name, rhs.zone_name)) { + return apache::thrift::StringTraits::isLess(lhs.zone_name, rhs.zone_name); + } + if (!(lhs.nodes == rhs.nodes)) { + return lhs.nodes < rhs.nodes; + } + return false; +} + +const ::std::vector& AddZoneReq::get_nodes() const& { + return nodes; +} + +::std::vector AddZoneReq::get_nodes() && { + return std::move(nodes); +} + + +void swap(AddZoneReq& a, AddZoneReq& b) { + using ::std::swap; + swap(a.zone_name_ref().value(), b.zone_name_ref().value()); + swap(a.nodes_ref().value(), b.nodes_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void AddZoneReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t AddZoneReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t AddZoneReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t AddZoneReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void AddZoneReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t AddZoneReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t AddZoneReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t AddZoneReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + AddZoneReq, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + AddZoneReq, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector>, + "inconsistent use of nimble option"); + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::DropZoneReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::DropZoneReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +DropZoneReq::DropZoneReq(apache::thrift::FragileConstructor, ::std::string zone_name__arg) : + zone_name(std::move(zone_name__arg)) { + __isset.zone_name = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void DropZoneReq::__clear() { + // clear all fields + zone_name = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool DropZoneReq::operator==(const DropZoneReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!apache::thrift::StringTraits::isEqual(lhs.zone_name, rhs.zone_name)) { + return false; + } + return true; +} + +bool DropZoneReq::operator<(const DropZoneReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!apache::thrift::StringTraits::isEqual(lhs.zone_name, rhs.zone_name)) { + return apache::thrift::StringTraits::isLess(lhs.zone_name, rhs.zone_name); + } + return false; +} + + +void swap(DropZoneReq& a, DropZoneReq& b) { + using ::std::swap; + swap(a.zone_name_ref().value(), b.zone_name_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void DropZoneReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t DropZoneReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t DropZoneReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t DropZoneReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void DropZoneReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t DropZoneReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t DropZoneReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t DropZoneReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::AddHostIntoZoneReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::AddHostIntoZoneReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +AddHostIntoZoneReq::AddHostIntoZoneReq(apache::thrift::FragileConstructor, nebula::HostAddr node__arg, ::std::string zone_name__arg) : + node(std::move(node__arg)), + zone_name(std::move(zone_name__arg)) { + __isset.node = true; + __isset.zone_name = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void AddHostIntoZoneReq::__clear() { + // clear all fields + node.__clear(); + zone_name = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool AddHostIntoZoneReq::operator==(const AddHostIntoZoneReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.node == rhs.node)) { + return false; + } + if (!apache::thrift::StringTraits::isEqual(lhs.zone_name, rhs.zone_name)) { + return false; + } + return true; +} + +bool AddHostIntoZoneReq::operator<(const AddHostIntoZoneReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.node == rhs.node)) { + return lhs.node < rhs.node; + } + if (!apache::thrift::StringTraits::isEqual(lhs.zone_name, rhs.zone_name)) { + return apache::thrift::StringTraits::isLess(lhs.zone_name, rhs.zone_name); + } + return false; +} + +const nebula::HostAddr& AddHostIntoZoneReq::get_node() const& { + return node; +} + +nebula::HostAddr AddHostIntoZoneReq::get_node() && { + return std::move(node); +} + + +void swap(AddHostIntoZoneReq& a, AddHostIntoZoneReq& b) { + using ::std::swap; + swap(a.node_ref().value(), b.node_ref().value()); + swap(a.zone_name_ref().value(), b.zone_name_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void AddHostIntoZoneReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t AddHostIntoZoneReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t AddHostIntoZoneReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t AddHostIntoZoneReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void AddHostIntoZoneReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t AddHostIntoZoneReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t AddHostIntoZoneReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t AddHostIntoZoneReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + AddHostIntoZoneReq, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + AddHostIntoZoneReq, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of nimble option"); + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::DropHostFromZoneReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::DropHostFromZoneReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +DropHostFromZoneReq::DropHostFromZoneReq(apache::thrift::FragileConstructor, nebula::HostAddr node__arg, ::std::string zone_name__arg) : + node(std::move(node__arg)), + zone_name(std::move(zone_name__arg)) { + __isset.node = true; + __isset.zone_name = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void DropHostFromZoneReq::__clear() { + // clear all fields + node.__clear(); + zone_name = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool DropHostFromZoneReq::operator==(const DropHostFromZoneReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.node == rhs.node)) { + return false; + } + if (!apache::thrift::StringTraits::isEqual(lhs.zone_name, rhs.zone_name)) { + return false; + } + return true; +} + +bool DropHostFromZoneReq::operator<(const DropHostFromZoneReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.node == rhs.node)) { + return lhs.node < rhs.node; + } + if (!apache::thrift::StringTraits::isEqual(lhs.zone_name, rhs.zone_name)) { + return apache::thrift::StringTraits::isLess(lhs.zone_name, rhs.zone_name); + } + return false; +} + +const nebula::HostAddr& DropHostFromZoneReq::get_node() const& { + return node; +} + +nebula::HostAddr DropHostFromZoneReq::get_node() && { + return std::move(node); +} + + +void swap(DropHostFromZoneReq& a, DropHostFromZoneReq& b) { + using ::std::swap; + swap(a.node_ref().value(), b.node_ref().value()); + swap(a.zone_name_ref().value(), b.zone_name_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void DropHostFromZoneReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t DropHostFromZoneReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t DropHostFromZoneReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t DropHostFromZoneReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void DropHostFromZoneReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t DropHostFromZoneReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t DropHostFromZoneReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t DropHostFromZoneReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + DropHostFromZoneReq, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + DropHostFromZoneReq, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of nimble option"); + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::GetZoneReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::GetZoneReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +GetZoneReq::GetZoneReq(apache::thrift::FragileConstructor, ::std::string zone_name__arg) : + zone_name(std::move(zone_name__arg)) { + __isset.zone_name = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void GetZoneReq::__clear() { + // clear all fields + zone_name = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool GetZoneReq::operator==(const GetZoneReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!apache::thrift::StringTraits::isEqual(lhs.zone_name, rhs.zone_name)) { + return false; + } + return true; +} + +bool GetZoneReq::operator<(const GetZoneReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!apache::thrift::StringTraits::isEqual(lhs.zone_name, rhs.zone_name)) { + return apache::thrift::StringTraits::isLess(lhs.zone_name, rhs.zone_name); + } + return false; +} + + +void swap(GetZoneReq& a, GetZoneReq& b) { + using ::std::swap; + swap(a.zone_name_ref().value(), b.zone_name_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void GetZoneReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t GetZoneReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t GetZoneReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t GetZoneReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void GetZoneReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t GetZoneReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t GetZoneReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t GetZoneReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::GetZoneResp>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::GetZoneResp>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +GetZoneResp::GetZoneResp(apache::thrift::FragileConstructor, ::nebula::cpp2::ErrorCode code__arg, nebula::HostAddr leader__arg, ::std::vector hosts__arg) : + code(std::move(code__arg)), + leader(std::move(leader__arg)), + hosts(std::move(hosts__arg)) { + __isset.code = true; + __isset.leader = true; + __isset.hosts = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void GetZoneResp::__clear() { + // clear all fields + code = ::nebula::cpp2::ErrorCode::SUCCEEDED; + leader.__clear(); + hosts.clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool GetZoneResp::operator==(const GetZoneResp& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.code == rhs.code)) { + return false; + } + if (!(lhs.leader == rhs.leader)) { + return false; + } + if (!(lhs.hosts == rhs.hosts)) { + return false; + } + return true; +} + +bool GetZoneResp::operator<(const GetZoneResp& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.code == rhs.code)) { + return lhs.code < rhs.code; + } + if (!(lhs.leader == rhs.leader)) { + return lhs.leader < rhs.leader; + } + if (!(lhs.hosts == rhs.hosts)) { + return lhs.hosts < rhs.hosts; + } + return false; +} + +const nebula::HostAddr& GetZoneResp::get_leader() const& { + return leader; +} + +nebula::HostAddr GetZoneResp::get_leader() && { + return std::move(leader); +} + +const ::std::vector& GetZoneResp::get_hosts() const& { + return hosts; +} + +::std::vector GetZoneResp::get_hosts() && { + return std::move(hosts); +} + + +void swap(GetZoneResp& a, GetZoneResp& b) { + using ::std::swap; + swap(a.code_ref().value(), b.code_ref().value()); + swap(a.leader_ref().value(), b.leader_ref().value()); + swap(a.hosts_ref().value(), b.hosts_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void GetZoneResp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t GetZoneResp::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t GetZoneResp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t GetZoneResp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void GetZoneResp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t GetZoneResp::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t GetZoneResp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t GetZoneResp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + GetZoneResp, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + GetZoneResp, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + GetZoneResp, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + GetZoneResp, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector>, + "inconsistent use of nimble option"); + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::ListZonesReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::ListZonesReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +ListZonesReq::ListZonesReq(apache::thrift::FragileConstructor) {} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void ListZonesReq::__clear() { + // clear all fields +} + +bool ListZonesReq::operator==(const ListZonesReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + return true; +} + +bool ListZonesReq::operator<(const ListZonesReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + return false; +} + + +void swap(ListZonesReq& a, ListZonesReq& b) { + using ::std::swap; + (void)a; + (void)b; +} + +template void ListZonesReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t ListZonesReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t ListZonesReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t ListZonesReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void ListZonesReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t ListZonesReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t ListZonesReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t ListZonesReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::Zone>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::Zone>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +Zone::Zone(apache::thrift::FragileConstructor, ::std::string zone_name__arg, ::std::vector nodes__arg) : + zone_name(std::move(zone_name__arg)), + nodes(std::move(nodes__arg)) { + __isset.zone_name = true; + __isset.nodes = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void Zone::__clear() { + // clear all fields + zone_name = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); + nodes.clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool Zone::operator==(const Zone& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!apache::thrift::StringTraits::isEqual(lhs.zone_name, rhs.zone_name)) { + return false; + } + if (!(lhs.nodes == rhs.nodes)) { + return false; + } + return true; +} + +bool Zone::operator<(const Zone& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!apache::thrift::StringTraits::isEqual(lhs.zone_name, rhs.zone_name)) { + return apache::thrift::StringTraits::isLess(lhs.zone_name, rhs.zone_name); + } + if (!(lhs.nodes == rhs.nodes)) { + return lhs.nodes < rhs.nodes; + } + return false; +} + +const ::std::vector& Zone::get_nodes() const& { + return nodes; +} + +::std::vector Zone::get_nodes() && { + return std::move(nodes); +} + + +void swap(Zone& a, Zone& b) { + using ::std::swap; + swap(a.zone_name_ref().value(), b.zone_name_ref().value()); + swap(a.nodes_ref().value(), b.nodes_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void Zone::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t Zone::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t Zone::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t Zone::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void Zone::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t Zone::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t Zone::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t Zone::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + Zone, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + Zone, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector>, + "inconsistent use of nimble option"); + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::ListZonesResp>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::ListZonesResp>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +ListZonesResp::ListZonesResp(apache::thrift::FragileConstructor, ::nebula::cpp2::ErrorCode code__arg, nebula::HostAddr leader__arg, ::std::vector< ::nebula::meta::cpp2::Zone> zones__arg) : + code(std::move(code__arg)), + leader(std::move(leader__arg)), + zones(std::move(zones__arg)) { + __isset.code = true; + __isset.leader = true; + __isset.zones = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void ListZonesResp::__clear() { + // clear all fields + code = ::nebula::cpp2::ErrorCode::SUCCEEDED; + leader.__clear(); + zones.clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool ListZonesResp::operator==(const ListZonesResp& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.code == rhs.code)) { + return false; + } + if (!(lhs.leader == rhs.leader)) { + return false; + } + if (!(lhs.zones == rhs.zones)) { + return false; + } + return true; +} + +bool ListZonesResp::operator<(const ListZonesResp& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.code == rhs.code)) { + return lhs.code < rhs.code; + } + if (!(lhs.leader == rhs.leader)) { + return lhs.leader < rhs.leader; + } + if (!(lhs.zones == rhs.zones)) { + return lhs.zones < rhs.zones; + } + return false; +} + +const nebula::HostAddr& ListZonesResp::get_leader() const& { + return leader; +} + +nebula::HostAddr ListZonesResp::get_leader() && { + return std::move(leader); +} + +const ::std::vector< ::nebula::meta::cpp2::Zone>& ListZonesResp::get_zones() const& { + return zones; +} + +::std::vector< ::nebula::meta::cpp2::Zone> ListZonesResp::get_zones() && { + return std::move(zones); +} + + +void swap(ListZonesResp& a, ListZonesResp& b) { + using ::std::swap; + swap(a.code_ref().value(), b.code_ref().value()); + swap(a.leader_ref().value(), b.leader_ref().value()); + swap(a.zones_ref().value(), b.zones_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void ListZonesResp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t ListZonesResp::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t ListZonesResp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t ListZonesResp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void ListZonesResp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t ListZonesResp::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t ListZonesResp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t ListZonesResp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + ListZonesResp, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + ListZonesResp, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector< ::nebula::meta::cpp2::Zone>>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + ListZonesResp, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + ListZonesResp, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector< ::nebula::meta::cpp2::Zone>>, + "inconsistent use of nimble option"); + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::AddGroupReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::AddGroupReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +AddGroupReq::AddGroupReq(apache::thrift::FragileConstructor, ::std::string group_name__arg, ::std::vector<::std::string> zone_names__arg) : + group_name(std::move(group_name__arg)), + zone_names(std::move(zone_names__arg)) { + __isset.group_name = true; + __isset.zone_names = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void AddGroupReq::__clear() { + // clear all fields + group_name = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); + zone_names.clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool AddGroupReq::operator==(const AddGroupReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!apache::thrift::StringTraits::isEqual(lhs.group_name, rhs.group_name)) { + return false; + } + if (!(lhs.zone_names == rhs.zone_names)) { + return false; + } + return true; +} + +bool AddGroupReq::operator<(const AddGroupReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!apache::thrift::StringTraits::isEqual(lhs.group_name, rhs.group_name)) { + return apache::thrift::StringTraits::isLess(lhs.group_name, rhs.group_name); + } + if (!(lhs.zone_names == rhs.zone_names)) { + return lhs.zone_names < rhs.zone_names; + } + return false; +} + +const ::std::vector<::std::string>& AddGroupReq::get_zone_names() const& { + return zone_names; +} + +::std::vector<::std::string> AddGroupReq::get_zone_names() && { + return std::move(zone_names); +} + + +void swap(AddGroupReq& a, AddGroupReq& b) { + using ::std::swap; + swap(a.group_name_ref().value(), b.group_name_ref().value()); + swap(a.zone_names_ref().value(), b.zone_names_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void AddGroupReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t AddGroupReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t AddGroupReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t AddGroupReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void AddGroupReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t AddGroupReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t AddGroupReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t AddGroupReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::DropGroupReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::DropGroupReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +DropGroupReq::DropGroupReq(apache::thrift::FragileConstructor, ::std::string group_name__arg) : + group_name(std::move(group_name__arg)) { + __isset.group_name = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void DropGroupReq::__clear() { + // clear all fields + group_name = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool DropGroupReq::operator==(const DropGroupReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!apache::thrift::StringTraits::isEqual(lhs.group_name, rhs.group_name)) { + return false; + } + return true; +} + +bool DropGroupReq::operator<(const DropGroupReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!apache::thrift::StringTraits::isEqual(lhs.group_name, rhs.group_name)) { + return apache::thrift::StringTraits::isLess(lhs.group_name, rhs.group_name); + } + return false; +} + + +void swap(DropGroupReq& a, DropGroupReq& b) { + using ::std::swap; + swap(a.group_name_ref().value(), b.group_name_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void DropGroupReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t DropGroupReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t DropGroupReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t DropGroupReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void DropGroupReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t DropGroupReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t DropGroupReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t DropGroupReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::AddZoneIntoGroupReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::AddZoneIntoGroupReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +AddZoneIntoGroupReq::AddZoneIntoGroupReq(apache::thrift::FragileConstructor, ::std::string zone_name__arg, ::std::string group_name__arg) : + zone_name(std::move(zone_name__arg)), + group_name(std::move(group_name__arg)) { + __isset.zone_name = true; + __isset.group_name = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void AddZoneIntoGroupReq::__clear() { + // clear all fields + zone_name = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); + group_name = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool AddZoneIntoGroupReq::operator==(const AddZoneIntoGroupReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!apache::thrift::StringTraits::isEqual(lhs.zone_name, rhs.zone_name)) { + return false; + } + if (!apache::thrift::StringTraits::isEqual(lhs.group_name, rhs.group_name)) { + return false; + } + return true; +} + +bool AddZoneIntoGroupReq::operator<(const AddZoneIntoGroupReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!apache::thrift::StringTraits::isEqual(lhs.zone_name, rhs.zone_name)) { + return apache::thrift::StringTraits::isLess(lhs.zone_name, rhs.zone_name); + } + if (!apache::thrift::StringTraits::isEqual(lhs.group_name, rhs.group_name)) { + return apache::thrift::StringTraits::isLess(lhs.group_name, rhs.group_name); + } + return false; +} + + +void swap(AddZoneIntoGroupReq& a, AddZoneIntoGroupReq& b) { + using ::std::swap; + swap(a.zone_name_ref().value(), b.zone_name_ref().value()); + swap(a.group_name_ref().value(), b.group_name_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void AddZoneIntoGroupReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t AddZoneIntoGroupReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t AddZoneIntoGroupReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t AddZoneIntoGroupReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void AddZoneIntoGroupReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t AddZoneIntoGroupReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t AddZoneIntoGroupReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t AddZoneIntoGroupReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::DropZoneFromGroupReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::DropZoneFromGroupReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +DropZoneFromGroupReq::DropZoneFromGroupReq(apache::thrift::FragileConstructor, ::std::string zone_name__arg, ::std::string group_name__arg) : + zone_name(std::move(zone_name__arg)), + group_name(std::move(group_name__arg)) { + __isset.zone_name = true; + __isset.group_name = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void DropZoneFromGroupReq::__clear() { + // clear all fields + zone_name = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); + group_name = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool DropZoneFromGroupReq::operator==(const DropZoneFromGroupReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!apache::thrift::StringTraits::isEqual(lhs.zone_name, rhs.zone_name)) { + return false; + } + if (!apache::thrift::StringTraits::isEqual(lhs.group_name, rhs.group_name)) { + return false; + } + return true; +} + +bool DropZoneFromGroupReq::operator<(const DropZoneFromGroupReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!apache::thrift::StringTraits::isEqual(lhs.zone_name, rhs.zone_name)) { + return apache::thrift::StringTraits::isLess(lhs.zone_name, rhs.zone_name); + } + if (!apache::thrift::StringTraits::isEqual(lhs.group_name, rhs.group_name)) { + return apache::thrift::StringTraits::isLess(lhs.group_name, rhs.group_name); + } + return false; +} + + +void swap(DropZoneFromGroupReq& a, DropZoneFromGroupReq& b) { + using ::std::swap; + swap(a.zone_name_ref().value(), b.zone_name_ref().value()); + swap(a.group_name_ref().value(), b.group_name_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void DropZoneFromGroupReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t DropZoneFromGroupReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t DropZoneFromGroupReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t DropZoneFromGroupReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void DropZoneFromGroupReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t DropZoneFromGroupReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t DropZoneFromGroupReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t DropZoneFromGroupReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::GetGroupReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::GetGroupReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +GetGroupReq::GetGroupReq(apache::thrift::FragileConstructor, ::std::string group_name__arg) : + group_name(std::move(group_name__arg)) { + __isset.group_name = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void GetGroupReq::__clear() { + // clear all fields + group_name = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool GetGroupReq::operator==(const GetGroupReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!apache::thrift::StringTraits::isEqual(lhs.group_name, rhs.group_name)) { + return false; + } + return true; +} + +bool GetGroupReq::operator<(const GetGroupReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!apache::thrift::StringTraits::isEqual(lhs.group_name, rhs.group_name)) { + return apache::thrift::StringTraits::isLess(lhs.group_name, rhs.group_name); + } + return false; +} + + +void swap(GetGroupReq& a, GetGroupReq& b) { + using ::std::swap; + swap(a.group_name_ref().value(), b.group_name_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void GetGroupReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t GetGroupReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t GetGroupReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t GetGroupReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void GetGroupReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t GetGroupReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t GetGroupReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t GetGroupReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::GetGroupResp>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::GetGroupResp>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +GetGroupResp::GetGroupResp(apache::thrift::FragileConstructor, ::nebula::cpp2::ErrorCode code__arg, nebula::HostAddr leader__arg, ::std::vector<::std::string> zone_names__arg) : + code(std::move(code__arg)), + leader(std::move(leader__arg)), + zone_names(std::move(zone_names__arg)) { + __isset.code = true; + __isset.leader = true; + __isset.zone_names = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void GetGroupResp::__clear() { + // clear all fields + code = ::nebula::cpp2::ErrorCode::SUCCEEDED; + leader.__clear(); + zone_names.clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool GetGroupResp::operator==(const GetGroupResp& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.code == rhs.code)) { + return false; + } + if (!(lhs.leader == rhs.leader)) { + return false; + } + if (!(lhs.zone_names == rhs.zone_names)) { + return false; + } + return true; +} + +bool GetGroupResp::operator<(const GetGroupResp& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.code == rhs.code)) { + return lhs.code < rhs.code; + } + if (!(lhs.leader == rhs.leader)) { + return lhs.leader < rhs.leader; + } + if (!(lhs.zone_names == rhs.zone_names)) { + return lhs.zone_names < rhs.zone_names; + } + return false; +} + +const nebula::HostAddr& GetGroupResp::get_leader() const& { + return leader; +} + +nebula::HostAddr GetGroupResp::get_leader() && { + return std::move(leader); +} + +const ::std::vector<::std::string>& GetGroupResp::get_zone_names() const& { + return zone_names; +} + +::std::vector<::std::string> GetGroupResp::get_zone_names() && { + return std::move(zone_names); +} + + +void swap(GetGroupResp& a, GetGroupResp& b) { + using ::std::swap; + swap(a.code_ref().value(), b.code_ref().value()); + swap(a.leader_ref().value(), b.leader_ref().value()); + swap(a.zone_names_ref().value(), b.zone_names_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void GetGroupResp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t GetGroupResp::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t GetGroupResp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t GetGroupResp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void GetGroupResp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t GetGroupResp::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t GetGroupResp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t GetGroupResp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + GetGroupResp, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + GetGroupResp, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of nimble option"); + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::ListGroupsReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::ListGroupsReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +ListGroupsReq::ListGroupsReq(apache::thrift::FragileConstructor) {} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void ListGroupsReq::__clear() { + // clear all fields +} + +bool ListGroupsReq::operator==(const ListGroupsReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + return true; +} + +bool ListGroupsReq::operator<(const ListGroupsReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + return false; +} + + +void swap(ListGroupsReq& a, ListGroupsReq& b) { + using ::std::swap; + (void)a; + (void)b; +} + +template void ListGroupsReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t ListGroupsReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t ListGroupsReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t ListGroupsReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void ListGroupsReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t ListGroupsReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t ListGroupsReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t ListGroupsReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::Group>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::Group>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +Group::Group(apache::thrift::FragileConstructor, ::std::string group_name__arg, ::std::vector<::std::string> zone_names__arg) : + group_name(std::move(group_name__arg)), + zone_names(std::move(zone_names__arg)) { + __isset.group_name = true; + __isset.zone_names = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void Group::__clear() { + // clear all fields + group_name = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); + zone_names.clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool Group::operator==(const Group& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!apache::thrift::StringTraits::isEqual(lhs.group_name, rhs.group_name)) { + return false; + } + if (!(lhs.zone_names == rhs.zone_names)) { + return false; + } + return true; +} + +bool Group::operator<(const Group& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!apache::thrift::StringTraits::isEqual(lhs.group_name, rhs.group_name)) { + return apache::thrift::StringTraits::isLess(lhs.group_name, rhs.group_name); + } + if (!(lhs.zone_names == rhs.zone_names)) { + return lhs.zone_names < rhs.zone_names; + } + return false; +} + +const ::std::vector<::std::string>& Group::get_zone_names() const& { + return zone_names; +} + +::std::vector<::std::string> Group::get_zone_names() && { + return std::move(zone_names); +} + + +void swap(Group& a, Group& b) { + using ::std::swap; + swap(a.group_name_ref().value(), b.group_name_ref().value()); + swap(a.zone_names_ref().value(), b.zone_names_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void Group::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t Group::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t Group::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t Group::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void Group::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t Group::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t Group::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t Group::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::ListGroupsResp>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::ListGroupsResp>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +ListGroupsResp::ListGroupsResp(apache::thrift::FragileConstructor, ::nebula::cpp2::ErrorCode code__arg, nebula::HostAddr leader__arg, ::std::vector< ::nebula::meta::cpp2::Group> groups__arg) : + code(std::move(code__arg)), + leader(std::move(leader__arg)), + groups(std::move(groups__arg)) { + __isset.code = true; + __isset.leader = true; + __isset.groups = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void ListGroupsResp::__clear() { + // clear all fields + code = ::nebula::cpp2::ErrorCode::SUCCEEDED; + leader.__clear(); + groups.clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool ListGroupsResp::operator==(const ListGroupsResp& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.code == rhs.code)) { + return false; + } + if (!(lhs.leader == rhs.leader)) { + return false; + } + if (!(lhs.groups == rhs.groups)) { + return false; + } + return true; +} + +bool ListGroupsResp::operator<(const ListGroupsResp& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.code == rhs.code)) { + return lhs.code < rhs.code; + } + if (!(lhs.leader == rhs.leader)) { + return lhs.leader < rhs.leader; + } + if (!(lhs.groups == rhs.groups)) { + return lhs.groups < rhs.groups; + } + return false; +} + +const nebula::HostAddr& ListGroupsResp::get_leader() const& { + return leader; +} + +nebula::HostAddr ListGroupsResp::get_leader() && { + return std::move(leader); +} + +const ::std::vector< ::nebula::meta::cpp2::Group>& ListGroupsResp::get_groups() const& { + return groups; +} + +::std::vector< ::nebula::meta::cpp2::Group> ListGroupsResp::get_groups() && { + return std::move(groups); +} + + +void swap(ListGroupsResp& a, ListGroupsResp& b) { + using ::std::swap; + swap(a.code_ref().value(), b.code_ref().value()); + swap(a.leader_ref().value(), b.leader_ref().value()); + swap(a.groups_ref().value(), b.groups_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void ListGroupsResp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t ListGroupsResp::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t ListGroupsResp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t ListGroupsResp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void ListGroupsResp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t ListGroupsResp::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t ListGroupsResp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t ListGroupsResp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + ListGroupsResp, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + ListGroupsResp, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector< ::nebula::meta::cpp2::Group>>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + ListGroupsResp, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + ListGroupsResp, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector< ::nebula::meta::cpp2::Group>>, + "inconsistent use of nimble option"); + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::AddListenerReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::AddListenerReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +AddListenerReq::AddListenerReq(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, ::nebula::meta::cpp2::ListenerType type__arg, ::std::vector hosts__arg) : + space_id(std::move(space_id__arg)), + type(std::move(type__arg)), + hosts(std::move(hosts__arg)) { + __isset.space_id = true; + __isset.type = true; + __isset.hosts = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void AddListenerReq::__clear() { + // clear all fields + space_id = 0; + type = ::nebula::meta::cpp2::ListenerType::UNKNOWN; + hosts.clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool AddListenerReq::operator==(const AddListenerReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return false; + } + if (!(lhs.type == rhs.type)) { + return false; + } + if (!(lhs.hosts == rhs.hosts)) { + return false; + } + return true; +} + +bool AddListenerReq::operator<(const AddListenerReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return lhs.space_id < rhs.space_id; + } + if (!(lhs.type == rhs.type)) { + return lhs.type < rhs.type; + } + if (!(lhs.hosts == rhs.hosts)) { + return lhs.hosts < rhs.hosts; + } + return false; +} + +const ::std::vector& AddListenerReq::get_hosts() const& { + return hosts; +} + +::std::vector AddListenerReq::get_hosts() && { + return std::move(hosts); +} + + +void swap(AddListenerReq& a, AddListenerReq& b) { + using ::std::swap; + swap(a.space_id_ref().value(), b.space_id_ref().value()); + swap(a.type_ref().value(), b.type_ref().value()); + swap(a.hosts_ref().value(), b.hosts_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void AddListenerReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t AddListenerReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t AddListenerReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t AddListenerReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void AddListenerReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t AddListenerReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t AddListenerReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t AddListenerReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + AddListenerReq, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + AddListenerReq, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector>, + "inconsistent use of nimble option"); + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::RemoveListenerReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::RemoveListenerReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +RemoveListenerReq::RemoveListenerReq(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, ::nebula::meta::cpp2::ListenerType type__arg) : + space_id(std::move(space_id__arg)), + type(std::move(type__arg)) { + __isset.space_id = true; + __isset.type = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void RemoveListenerReq::__clear() { + // clear all fields + space_id = 0; + type = ::nebula::meta::cpp2::ListenerType::UNKNOWN; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool RemoveListenerReq::operator==(const RemoveListenerReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return false; + } + if (!(lhs.type == rhs.type)) { + return false; + } + return true; +} + +bool RemoveListenerReq::operator<(const RemoveListenerReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return lhs.space_id < rhs.space_id; + } + if (!(lhs.type == rhs.type)) { + return lhs.type < rhs.type; + } + return false; +} + + +void swap(RemoveListenerReq& a, RemoveListenerReq& b) { + using ::std::swap; + swap(a.space_id_ref().value(), b.space_id_ref().value()); + swap(a.type_ref().value(), b.type_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void RemoveListenerReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t RemoveListenerReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t RemoveListenerReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t RemoveListenerReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void RemoveListenerReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t RemoveListenerReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t RemoveListenerReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t RemoveListenerReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::ListListenerReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::ListListenerReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +ListListenerReq::ListListenerReq(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg) : + space_id(std::move(space_id__arg)) { + __isset.space_id = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void ListListenerReq::__clear() { + // clear all fields + space_id = 0; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool ListListenerReq::operator==(const ListListenerReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return false; + } + return true; +} + +bool ListListenerReq::operator<(const ListListenerReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return lhs.space_id < rhs.space_id; + } + return false; +} + + +void swap(ListListenerReq& a, ListListenerReq& b) { + using ::std::swap; + swap(a.space_id_ref().value(), b.space_id_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void ListListenerReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t ListListenerReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t ListListenerReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t ListListenerReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void ListListenerReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t ListListenerReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t ListListenerReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t ListListenerReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::ListenerInfo>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::ListenerInfo>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +ListenerInfo::ListenerInfo(apache::thrift::FragileConstructor, ::nebula::meta::cpp2::ListenerType type__arg, nebula::HostAddr host__arg, ::nebula::cpp2::PartitionID part_id__arg, ::nebula::meta::cpp2::HostStatus status__arg) : + type(std::move(type__arg)), + host(std::move(host__arg)), + part_id(std::move(part_id__arg)), + status(std::move(status__arg)) { + __isset.type = true; + __isset.host = true; + __isset.part_id = true; + __isset.status = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void ListenerInfo::__clear() { + // clear all fields + type = ::nebula::meta::cpp2::ListenerType::UNKNOWN; + host.__clear(); + part_id = 0; + status = ::nebula::meta::cpp2::HostStatus::ONLINE; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool ListenerInfo::operator==(const ListenerInfo& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.type == rhs.type)) { + return false; + } + if (!(lhs.host == rhs.host)) { + return false; + } + if (!(lhs.part_id == rhs.part_id)) { + return false; + } + if (!(lhs.status == rhs.status)) { + return false; + } + return true; +} + +bool ListenerInfo::operator<(const ListenerInfo& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.type == rhs.type)) { + return lhs.type < rhs.type; + } + if (!(lhs.host == rhs.host)) { + return lhs.host < rhs.host; + } + if (!(lhs.part_id == rhs.part_id)) { + return lhs.part_id < rhs.part_id; + } + if (!(lhs.status == rhs.status)) { + return lhs.status < rhs.status; + } + return false; +} + +const nebula::HostAddr& ListenerInfo::get_host() const& { + return host; +} + +nebula::HostAddr ListenerInfo::get_host() && { + return std::move(host); +} + + +void swap(ListenerInfo& a, ListenerInfo& b) { + using ::std::swap; + swap(a.type_ref().value(), b.type_ref().value()); + swap(a.host_ref().value(), b.host_ref().value()); + swap(a.part_id_ref().value(), b.part_id_ref().value()); + swap(a.status_ref().value(), b.status_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void ListenerInfo::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t ListenerInfo::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t ListenerInfo::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t ListenerInfo::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void ListenerInfo::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t ListenerInfo::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t ListenerInfo::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t ListenerInfo::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + ListenerInfo, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + ListenerInfo, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of nimble option"); + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::ListListenerResp>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::ListListenerResp>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +ListListenerResp::ListListenerResp(apache::thrift::FragileConstructor, ::nebula::cpp2::ErrorCode code__arg, nebula::HostAddr leader__arg, ::std::vector< ::nebula::meta::cpp2::ListenerInfo> listeners__arg) : + code(std::move(code__arg)), + leader(std::move(leader__arg)), + listeners(std::move(listeners__arg)) { + __isset.code = true; + __isset.leader = true; + __isset.listeners = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void ListListenerResp::__clear() { + // clear all fields + code = ::nebula::cpp2::ErrorCode::SUCCEEDED; + leader.__clear(); + listeners.clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool ListListenerResp::operator==(const ListListenerResp& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.code == rhs.code)) { + return false; + } + if (!(lhs.leader == rhs.leader)) { + return false; + } + if (!(lhs.listeners == rhs.listeners)) { + return false; + } + return true; +} + +bool ListListenerResp::operator<(const ListListenerResp& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.code == rhs.code)) { + return lhs.code < rhs.code; + } + if (!(lhs.leader == rhs.leader)) { + return lhs.leader < rhs.leader; + } + if (!(lhs.listeners == rhs.listeners)) { + return lhs.listeners < rhs.listeners; + } + return false; +} + +const nebula::HostAddr& ListListenerResp::get_leader() const& { + return leader; +} + +nebula::HostAddr ListListenerResp::get_leader() && { + return std::move(leader); +} + +const ::std::vector< ::nebula::meta::cpp2::ListenerInfo>& ListListenerResp::get_listeners() const& { + return listeners; +} + +::std::vector< ::nebula::meta::cpp2::ListenerInfo> ListListenerResp::get_listeners() && { + return std::move(listeners); +} + + +void swap(ListListenerResp& a, ListListenerResp& b) { + using ::std::swap; + swap(a.code_ref().value(), b.code_ref().value()); + swap(a.leader_ref().value(), b.leader_ref().value()); + swap(a.listeners_ref().value(), b.listeners_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void ListListenerResp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t ListListenerResp::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t ListListenerResp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t ListListenerResp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void ListListenerResp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t ListListenerResp::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t ListListenerResp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t ListListenerResp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + ListListenerResp, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + ListListenerResp, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector< ::nebula::meta::cpp2::ListenerInfo>>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + ListListenerResp, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + ListListenerResp, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector< ::nebula::meta::cpp2::ListenerInfo>>, + "inconsistent use of nimble option"); + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::GetStatsReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::GetStatsReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +GetStatsReq::GetStatsReq(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg) : + space_id(std::move(space_id__arg)) { + __isset.space_id = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void GetStatsReq::__clear() { + // clear all fields + space_id = 0; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool GetStatsReq::operator==(const GetStatsReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return false; + } + return true; +} + +bool GetStatsReq::operator<(const GetStatsReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return lhs.space_id < rhs.space_id; + } + return false; +} + + +void swap(GetStatsReq& a, GetStatsReq& b) { + using ::std::swap; + swap(a.space_id_ref().value(), b.space_id_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void GetStatsReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t GetStatsReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t GetStatsReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t GetStatsReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void GetStatsReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t GetStatsReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t GetStatsReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t GetStatsReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::GetStatsResp>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::GetStatsResp>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +GetStatsResp::GetStatsResp(apache::thrift::FragileConstructor, ::nebula::cpp2::ErrorCode code__arg, nebula::HostAddr leader__arg, ::nebula::meta::cpp2::StatsItem stats__arg) : + code(std::move(code__arg)), + leader(std::move(leader__arg)), + stats(std::move(stats__arg)) { + __isset.code = true; + __isset.leader = true; + __isset.stats = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void GetStatsResp::__clear() { + // clear all fields + code = ::nebula::cpp2::ErrorCode::SUCCEEDED; + leader.__clear(); + stats.__clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool GetStatsResp::operator==(const GetStatsResp& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.code == rhs.code)) { + return false; + } + if (!(lhs.leader == rhs.leader)) { + return false; + } + if (!(lhs.stats == rhs.stats)) { + return false; + } + return true; +} + +const nebula::HostAddr& GetStatsResp::get_leader() const& { + return leader; +} + +nebula::HostAddr GetStatsResp::get_leader() && { + return std::move(leader); +} + +const ::nebula::meta::cpp2::StatsItem& GetStatsResp::get_stats() const& { + return stats; +} + + ::nebula::meta::cpp2::StatsItem GetStatsResp::get_stats() && { + return std::move(stats); +} + + +void swap(GetStatsResp& a, GetStatsResp& b) { + using ::std::swap; + swap(a.code_ref().value(), b.code_ref().value()); + swap(a.leader_ref().value(), b.leader_ref().value()); + swap(a.stats_ref().value(), b.stats_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void GetStatsResp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t GetStatsResp::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t GetStatsResp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t GetStatsResp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void GetStatsResp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t GetStatsResp::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t GetStatsResp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t GetStatsResp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + GetStatsResp, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + GetStatsResp, + ::apache::thrift::type_class::structure, + ::nebula::meta::cpp2::StatsItem>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + GetStatsResp, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + GetStatsResp, + ::apache::thrift::type_class::structure, + ::nebula::meta::cpp2::StatsItem>, + "inconsistent use of nimble option"); + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::BackupInfo>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::BackupInfo>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +BackupInfo::BackupInfo(apache::thrift::FragileConstructor, nebula::HostAddr host__arg, ::std::vector< ::nebula::cpp2::CheckpointInfo> info__arg) : + host(std::move(host__arg)), + info(std::move(info__arg)) { + __isset.host = true; + __isset.info = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void BackupInfo::__clear() { + // clear all fields + host.__clear(); + info.clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool BackupInfo::operator==(const BackupInfo& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.host == rhs.host)) { + return false; + } + if (!(lhs.info == rhs.info)) { + return false; + } + return true; +} + +const nebula::HostAddr& BackupInfo::get_host() const& { + return host; +} + +nebula::HostAddr BackupInfo::get_host() && { + return std::move(host); +} + +const ::std::vector< ::nebula::cpp2::CheckpointInfo>& BackupInfo::get_info() const& { + return info; +} + +::std::vector< ::nebula::cpp2::CheckpointInfo> BackupInfo::get_info() && { + return std::move(info); +} + + +void swap(BackupInfo& a, BackupInfo& b) { + using ::std::swap; + swap(a.host_ref().value(), b.host_ref().value()); + swap(a.info_ref().value(), b.info_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void BackupInfo::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t BackupInfo::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t BackupInfo::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t BackupInfo::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void BackupInfo::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t BackupInfo::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t BackupInfo::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t BackupInfo::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + BackupInfo, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + BackupInfo, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector< ::nebula::cpp2::CheckpointInfo>>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + BackupInfo, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + BackupInfo, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector< ::nebula::cpp2::CheckpointInfo>>, + "inconsistent use of nimble option"); + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::SpaceBackupInfo>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::SpaceBackupInfo>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +SpaceBackupInfo::SpaceBackupInfo(apache::thrift::FragileConstructor, ::nebula::meta::cpp2::SpaceDesc space__arg, ::std::vector< ::nebula::meta::cpp2::BackupInfo> info__arg) : + space(std::move(space__arg)), + info(std::move(info__arg)) { + __isset.space = true; + __isset.info = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void SpaceBackupInfo::__clear() { + // clear all fields + space.__clear(); + info.clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool SpaceBackupInfo::operator==(const SpaceBackupInfo& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space == rhs.space)) { + return false; + } + if (!(lhs.info == rhs.info)) { + return false; + } + return true; +} + +const ::nebula::meta::cpp2::SpaceDesc& SpaceBackupInfo::get_space() const& { + return space; +} + + ::nebula::meta::cpp2::SpaceDesc SpaceBackupInfo::get_space() && { + return std::move(space); +} + +const ::std::vector< ::nebula::meta::cpp2::BackupInfo>& SpaceBackupInfo::get_info() const& { + return info; +} + +::std::vector< ::nebula::meta::cpp2::BackupInfo> SpaceBackupInfo::get_info() && { + return std::move(info); +} + + +void swap(SpaceBackupInfo& a, SpaceBackupInfo& b) { + using ::std::swap; + swap(a.space_ref().value(), b.space_ref().value()); + swap(a.info_ref().value(), b.info_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void SpaceBackupInfo::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t SpaceBackupInfo::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t SpaceBackupInfo::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t SpaceBackupInfo::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void SpaceBackupInfo::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t SpaceBackupInfo::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t SpaceBackupInfo::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t SpaceBackupInfo::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + SpaceBackupInfo, + ::apache::thrift::type_class::structure, + ::nebula::meta::cpp2::SpaceDesc>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + SpaceBackupInfo, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector< ::nebula::meta::cpp2::BackupInfo>>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + SpaceBackupInfo, + ::apache::thrift::type_class::structure, + ::nebula::meta::cpp2::SpaceDesc>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + SpaceBackupInfo, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector< ::nebula::meta::cpp2::BackupInfo>>, + "inconsistent use of nimble option"); + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::BackupMeta>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::BackupMeta>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +BackupMeta::BackupMeta() : + full(0), + include_system_space(0), + create_time(0) {} +THRIFT_IGNORE_ISSET_USE_WARNING_END + + +BackupMeta::~BackupMeta() {} + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +BackupMeta::BackupMeta(apache::thrift::FragileConstructor, std::unordered_map< ::nebula::cpp2::GraphSpaceID, ::nebula::meta::cpp2::SpaceBackupInfo> backup_info__arg, ::std::vector<::std::string> meta_files__arg, ::std::string backup_name__arg, bool full__arg, bool include_system_space__arg, int64_t create_time__arg) : + backup_info(std::move(backup_info__arg)), + meta_files(std::move(meta_files__arg)), + backup_name(std::move(backup_name__arg)), + full(std::move(full__arg)), + include_system_space(std::move(include_system_space__arg)), + create_time(std::move(create_time__arg)) { + __isset.backup_info = true; + __isset.meta_files = true; + __isset.backup_name = true; + __isset.full = true; + __isset.include_system_space = true; + __isset.create_time = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void BackupMeta::__clear() { + // clear all fields + backup_info.clear(); + meta_files.clear(); + backup_name = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); + full = 0; + include_system_space = 0; + create_time = 0; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool BackupMeta::operator==(const BackupMeta& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.backup_info == rhs.backup_info)) { + return false; + } + if (!(lhs.meta_files == rhs.meta_files)) { + return false; + } + if (!apache::thrift::StringTraits::isEqual(lhs.backup_name, rhs.backup_name)) { + return false; + } + if (!(lhs.full == rhs.full)) { + return false; + } + if (!(lhs.include_system_space == rhs.include_system_space)) { + return false; + } + if (!(lhs.create_time == rhs.create_time)) { + return false; + } + return true; +} + +const std::unordered_map< ::nebula::cpp2::GraphSpaceID, ::nebula::meta::cpp2::SpaceBackupInfo>& BackupMeta::get_backup_info() const& { + return backup_info; +} + +std::unordered_map< ::nebula::cpp2::GraphSpaceID, ::nebula::meta::cpp2::SpaceBackupInfo> BackupMeta::get_backup_info() && { + return std::move(backup_info); +} + +const ::std::vector<::std::string>& BackupMeta::get_meta_files() const& { + return meta_files; +} + +::std::vector<::std::string> BackupMeta::get_meta_files() && { + return std::move(meta_files); +} + + +void swap(BackupMeta& a, BackupMeta& b) { + using ::std::swap; + swap(a.backup_info_ref().value(), b.backup_info_ref().value()); + swap(a.meta_files_ref().value(), b.meta_files_ref().value()); + swap(a.backup_name_ref().value(), b.backup_name_ref().value()); + swap(a.full_ref().value(), b.full_ref().value()); + swap(a.include_system_space_ref().value(), b.include_system_space_ref().value()); + swap(a.create_time_ref().value(), b.create_time_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void BackupMeta::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t BackupMeta::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t BackupMeta::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t BackupMeta::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void BackupMeta::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t BackupMeta::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t BackupMeta::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t BackupMeta::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + BackupMeta, + ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::structure>, + std::unordered_map< ::nebula::cpp2::GraphSpaceID, ::nebula::meta::cpp2::SpaceBackupInfo>>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + BackupMeta, + ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::structure>, + std::unordered_map< ::nebula::cpp2::GraphSpaceID, ::nebula::meta::cpp2::SpaceBackupInfo>>, + "inconsistent use of nimble option"); + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::CreateBackupReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::CreateBackupReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +CreateBackupReq::CreateBackupReq(apache::thrift::FragileConstructor, ::std::vector<::std::string> spaces__arg) : + spaces(std::move(spaces__arg)) { + __isset.spaces = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void CreateBackupReq::__clear() { + // clear all fields + spaces.clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool CreateBackupReq::operator==(const CreateBackupReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (lhs.spaces_ref() != rhs.spaces_ref()) { + return false; + } + return true; +} + +bool CreateBackupReq::operator<(const CreateBackupReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (lhs.spaces_ref() != rhs.spaces_ref()) { + return lhs.spaces_ref() < rhs.spaces_ref(); + } + return false; +} + +const ::std::vector<::std::string>* CreateBackupReq::get_spaces() const& { + return spaces_ref().has_value() ? std::addressof(spaces) : nullptr; +} + +::std::vector<::std::string>* CreateBackupReq::get_spaces() & { + return spaces_ref().has_value() ? std::addressof(spaces) : nullptr; +} + + +void swap(CreateBackupReq& a, CreateBackupReq& b) { + using ::std::swap; + swap(a.spaces_ref().value_unchecked(), b.spaces_ref().value_unchecked()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void CreateBackupReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t CreateBackupReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t CreateBackupReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t CreateBackupReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void CreateBackupReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t CreateBackupReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t CreateBackupReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t CreateBackupReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::CreateBackupResp>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::CreateBackupResp>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +CreateBackupResp::CreateBackupResp(apache::thrift::FragileConstructor, ::nebula::cpp2::ErrorCode code__arg, nebula::HostAddr leader__arg, ::nebula::meta::cpp2::BackupMeta meta__arg) : + code(std::move(code__arg)), + leader(std::move(leader__arg)), + meta(std::move(meta__arg)) { + __isset.code = true; + __isset.leader = true; + __isset.meta = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void CreateBackupResp::__clear() { + // clear all fields + code = ::nebula::cpp2::ErrorCode::SUCCEEDED; + leader.__clear(); + meta.__clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool CreateBackupResp::operator==(const CreateBackupResp& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.code == rhs.code)) { + return false; + } + if (!(lhs.leader == rhs.leader)) { + return false; + } + if (!(lhs.meta == rhs.meta)) { + return false; + } + return true; +} + +const nebula::HostAddr& CreateBackupResp::get_leader() const& { + return leader; +} + +nebula::HostAddr CreateBackupResp::get_leader() && { + return std::move(leader); +} + +const ::nebula::meta::cpp2::BackupMeta& CreateBackupResp::get_meta() const& { + return meta; +} + + ::nebula::meta::cpp2::BackupMeta CreateBackupResp::get_meta() && { + return std::move(meta); +} + + +void swap(CreateBackupResp& a, CreateBackupResp& b) { + using ::std::swap; + swap(a.code_ref().value(), b.code_ref().value()); + swap(a.leader_ref().value(), b.leader_ref().value()); + swap(a.meta_ref().value(), b.meta_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void CreateBackupResp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t CreateBackupResp::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t CreateBackupResp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t CreateBackupResp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void CreateBackupResp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t CreateBackupResp::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t CreateBackupResp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t CreateBackupResp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + CreateBackupResp, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + CreateBackupResp, + ::apache::thrift::type_class::structure, + ::nebula::meta::cpp2::BackupMeta>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + CreateBackupResp, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + CreateBackupResp, + ::apache::thrift::type_class::structure, + ::nebula::meta::cpp2::BackupMeta>, + "inconsistent use of nimble option"); + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::HostPair>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::HostPair>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +HostPair::HostPair(apache::thrift::FragileConstructor, nebula::HostAddr from_host__arg, nebula::HostAddr to_host__arg) : + from_host(std::move(from_host__arg)), + to_host(std::move(to_host__arg)) { + __isset.from_host = true; + __isset.to_host = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void HostPair::__clear() { + // clear all fields + from_host.__clear(); + to_host.__clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool HostPair::operator==(const HostPair& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.from_host == rhs.from_host)) { + return false; + } + if (!(lhs.to_host == rhs.to_host)) { + return false; + } + return true; +} + +bool HostPair::operator<(const HostPair& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.from_host == rhs.from_host)) { + return lhs.from_host < rhs.from_host; + } + if (!(lhs.to_host == rhs.to_host)) { + return lhs.to_host < rhs.to_host; + } + return false; +} + +const nebula::HostAddr& HostPair::get_from_host() const& { + return from_host; +} + +nebula::HostAddr HostPair::get_from_host() && { + return std::move(from_host); +} + +const nebula::HostAddr& HostPair::get_to_host() const& { + return to_host; +} + +nebula::HostAddr HostPair::get_to_host() && { + return std::move(to_host); +} + + +void swap(HostPair& a, HostPair& b) { + using ::std::swap; + swap(a.from_host_ref().value(), b.from_host_ref().value()); + swap(a.to_host_ref().value(), b.to_host_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void HostPair::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t HostPair::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t HostPair::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t HostPair::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void HostPair::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t HostPair::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t HostPair::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t HostPair::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + HostPair, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + HostPair, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + HostPair, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + HostPair, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of nimble option"); + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::RestoreMetaReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::RestoreMetaReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +RestoreMetaReq::RestoreMetaReq(apache::thrift::FragileConstructor, ::std::vector<::std::string> files__arg, ::std::vector< ::nebula::meta::cpp2::HostPair> hosts__arg) : + files(std::move(files__arg)), + hosts(std::move(hosts__arg)) { + __isset.files = true; + __isset.hosts = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void RestoreMetaReq::__clear() { + // clear all fields + files.clear(); + hosts.clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool RestoreMetaReq::operator==(const RestoreMetaReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.files == rhs.files)) { + return false; + } + if (!(lhs.hosts == rhs.hosts)) { + return false; + } + return true; +} + +bool RestoreMetaReq::operator<(const RestoreMetaReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.files == rhs.files)) { + return lhs.files < rhs.files; + } + if (!(lhs.hosts == rhs.hosts)) { + return lhs.hosts < rhs.hosts; + } + return false; +} + +const ::std::vector<::std::string>& RestoreMetaReq::get_files() const& { + return files; +} + +::std::vector<::std::string> RestoreMetaReq::get_files() && { + return std::move(files); +} + +const ::std::vector< ::nebula::meta::cpp2::HostPair>& RestoreMetaReq::get_hosts() const& { + return hosts; +} + +::std::vector< ::nebula::meta::cpp2::HostPair> RestoreMetaReq::get_hosts() && { + return std::move(hosts); +} + + +void swap(RestoreMetaReq& a, RestoreMetaReq& b) { + using ::std::swap; + swap(a.files_ref().value(), b.files_ref().value()); + swap(a.hosts_ref().value(), b.hosts_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void RestoreMetaReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t RestoreMetaReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t RestoreMetaReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t RestoreMetaReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void RestoreMetaReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t RestoreMetaReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t RestoreMetaReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t RestoreMetaReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + RestoreMetaReq, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector< ::nebula::meta::cpp2::HostPair>>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + RestoreMetaReq, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector< ::nebula::meta::cpp2::HostPair>>, + "inconsistent use of nimble option"); + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::FTClient>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::FTClient>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +FTClient::FTClient(apache::thrift::FragileConstructor, nebula::HostAddr host__arg, ::std::string user__arg, ::std::string pwd__arg) : + host(std::move(host__arg)), + user(std::move(user__arg)), + pwd(std::move(pwd__arg)) { + __isset.user = true; + __isset.pwd = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void FTClient::__clear() { + // clear all fields + host.__clear(); + user = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); + pwd = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool FTClient::operator==(const FTClient& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.host == rhs.host)) { + return false; + } + if (lhs.user_ref().has_value() != rhs.user_ref().has_value()) { + return false; + } + if (lhs.user_ref().has_value()) { + if (!apache::thrift::StringTraits::isEqual(lhs.user, rhs.user)) { + return false; + } + } + if (lhs.pwd_ref().has_value() != rhs.pwd_ref().has_value()) { + return false; + } + if (lhs.pwd_ref().has_value()) { + if (!apache::thrift::StringTraits::isEqual(lhs.pwd, rhs.pwd)) { + return false; + } + } + return true; +} + +bool FTClient::operator<(const FTClient& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.host == rhs.host)) { + return lhs.host < rhs.host; + } + if (lhs.user_ref().has_value() != rhs.user_ref().has_value()) { + return lhs.user_ref().has_value() < rhs.user_ref().has_value(); + } + if (lhs.user_ref().has_value()) { + if (!apache::thrift::StringTraits::isEqual(lhs.user, rhs.user)) { + return apache::thrift::StringTraits::isLess(lhs.user, rhs.user); + } + } + if (lhs.pwd_ref().has_value() != rhs.pwd_ref().has_value()) { + return lhs.pwd_ref().has_value() < rhs.pwd_ref().has_value(); + } + if (lhs.pwd_ref().has_value()) { + if (!apache::thrift::StringTraits::isEqual(lhs.pwd, rhs.pwd)) { + return apache::thrift::StringTraits::isLess(lhs.pwd, rhs.pwd); + } + } + return false; +} + +const nebula::HostAddr& FTClient::get_host() const& { + return host; +} + +nebula::HostAddr FTClient::get_host() && { + return std::move(host); +} + + +void swap(FTClient& a, FTClient& b) { + using ::std::swap; + swap(a.host_ref().value(), b.host_ref().value()); + swap(a.user_ref().value_unchecked(), b.user_ref().value_unchecked()); + swap(a.pwd_ref().value_unchecked(), b.pwd_ref().value_unchecked()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void FTClient::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t FTClient::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t FTClient::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t FTClient::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void FTClient::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t FTClient::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t FTClient::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t FTClient::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + FTClient, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + FTClient, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of nimble option"); + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::SignInFTServiceReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::SignInFTServiceReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +SignInFTServiceReq::SignInFTServiceReq(apache::thrift::FragileConstructor, ::nebula::meta::cpp2::FTServiceType type__arg, ::std::vector< ::nebula::meta::cpp2::FTClient> clients__arg) : + type(std::move(type__arg)), + clients(std::move(clients__arg)) { + __isset.type = true; + __isset.clients = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void SignInFTServiceReq::__clear() { + // clear all fields + type = static_cast< ::nebula::meta::cpp2::FTServiceType>(0); + clients.clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool SignInFTServiceReq::operator==(const SignInFTServiceReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.type == rhs.type)) { + return false; + } + if (!(lhs.clients == rhs.clients)) { + return false; + } + return true; +} + +bool SignInFTServiceReq::operator<(const SignInFTServiceReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.type == rhs.type)) { + return lhs.type < rhs.type; + } + if (!(lhs.clients == rhs.clients)) { + return lhs.clients < rhs.clients; + } + return false; +} + +const ::std::vector< ::nebula::meta::cpp2::FTClient>& SignInFTServiceReq::get_clients() const& { + return clients; +} + +::std::vector< ::nebula::meta::cpp2::FTClient> SignInFTServiceReq::get_clients() && { + return std::move(clients); +} + + +void swap(SignInFTServiceReq& a, SignInFTServiceReq& b) { + using ::std::swap; + swap(a.type_ref().value(), b.type_ref().value()); + swap(a.clients_ref().value(), b.clients_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void SignInFTServiceReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t SignInFTServiceReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t SignInFTServiceReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t SignInFTServiceReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void SignInFTServiceReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t SignInFTServiceReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t SignInFTServiceReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t SignInFTServiceReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + SignInFTServiceReq, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector< ::nebula::meta::cpp2::FTClient>>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + SignInFTServiceReq, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector< ::nebula::meta::cpp2::FTClient>>, + "inconsistent use of nimble option"); + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::SignOutFTServiceReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::SignOutFTServiceReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +SignOutFTServiceReq::SignOutFTServiceReq(apache::thrift::FragileConstructor) {} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void SignOutFTServiceReq::__clear() { + // clear all fields +} + +bool SignOutFTServiceReq::operator==(const SignOutFTServiceReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + return true; +} + +bool SignOutFTServiceReq::operator<(const SignOutFTServiceReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + return false; +} + + +void swap(SignOutFTServiceReq& a, SignOutFTServiceReq& b) { + using ::std::swap; + (void)a; + (void)b; +} + +template void SignOutFTServiceReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t SignOutFTServiceReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t SignOutFTServiceReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t SignOutFTServiceReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void SignOutFTServiceReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t SignOutFTServiceReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t SignOutFTServiceReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t SignOutFTServiceReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::ListFTClientsReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::ListFTClientsReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +ListFTClientsReq::ListFTClientsReq(apache::thrift::FragileConstructor) {} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void ListFTClientsReq::__clear() { + // clear all fields +} + +bool ListFTClientsReq::operator==(const ListFTClientsReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + return true; +} + +bool ListFTClientsReq::operator<(const ListFTClientsReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + return false; +} + + +void swap(ListFTClientsReq& a, ListFTClientsReq& b) { + using ::std::swap; + (void)a; + (void)b; +} + +template void ListFTClientsReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t ListFTClientsReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t ListFTClientsReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t ListFTClientsReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void ListFTClientsReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t ListFTClientsReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t ListFTClientsReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t ListFTClientsReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::ListFTClientsResp>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::ListFTClientsResp>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +ListFTClientsResp::ListFTClientsResp(apache::thrift::FragileConstructor, ::nebula::cpp2::ErrorCode code__arg, nebula::HostAddr leader__arg, ::std::vector< ::nebula::meta::cpp2::FTClient> clients__arg) : + code(std::move(code__arg)), + leader(std::move(leader__arg)), + clients(std::move(clients__arg)) { + __isset.code = true; + __isset.leader = true; + __isset.clients = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void ListFTClientsResp::__clear() { + // clear all fields + code = ::nebula::cpp2::ErrorCode::SUCCEEDED; + leader.__clear(); + clients.clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool ListFTClientsResp::operator==(const ListFTClientsResp& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.code == rhs.code)) { + return false; + } + if (!(lhs.leader == rhs.leader)) { + return false; + } + if (!(lhs.clients == rhs.clients)) { + return false; + } + return true; +} + +bool ListFTClientsResp::operator<(const ListFTClientsResp& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.code == rhs.code)) { + return lhs.code < rhs.code; + } + if (!(lhs.leader == rhs.leader)) { + return lhs.leader < rhs.leader; + } + if (!(lhs.clients == rhs.clients)) { + return lhs.clients < rhs.clients; + } + return false; +} + +const nebula::HostAddr& ListFTClientsResp::get_leader() const& { + return leader; +} + +nebula::HostAddr ListFTClientsResp::get_leader() && { + return std::move(leader); +} + +const ::std::vector< ::nebula::meta::cpp2::FTClient>& ListFTClientsResp::get_clients() const& { + return clients; +} + +::std::vector< ::nebula::meta::cpp2::FTClient> ListFTClientsResp::get_clients() && { + return std::move(clients); +} + + +void swap(ListFTClientsResp& a, ListFTClientsResp& b) { + using ::std::swap; + swap(a.code_ref().value(), b.code_ref().value()); + swap(a.leader_ref().value(), b.leader_ref().value()); + swap(a.clients_ref().value(), b.clients_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void ListFTClientsResp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t ListFTClientsResp::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t ListFTClientsResp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t ListFTClientsResp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void ListFTClientsResp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t ListFTClientsResp::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t ListFTClientsResp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t ListFTClientsResp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + ListFTClientsResp, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + ListFTClientsResp, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector< ::nebula::meta::cpp2::FTClient>>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + ListFTClientsResp, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + ListFTClientsResp, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector< ::nebula::meta::cpp2::FTClient>>, + "inconsistent use of nimble option"); + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::FTIndex>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::FTIndex>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +FTIndex::FTIndex(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, ::nebula::cpp2::SchemaID depend_schema__arg, ::std::vector<::std::string> fields__arg) : + space_id(std::move(space_id__arg)), + depend_schema(std::move(depend_schema__arg)), + fields(std::move(fields__arg)) { + __isset.space_id = true; + __isset.depend_schema = true; + __isset.fields = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void FTIndex::__clear() { + // clear all fields + space_id = 0; + depend_schema.__clear(); + fields.clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool FTIndex::operator==(const FTIndex& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return false; + } + if (!(lhs.depend_schema == rhs.depend_schema)) { + return false; + } + if (!(lhs.fields == rhs.fields)) { + return false; + } + return true; +} + +bool FTIndex::operator<(const FTIndex& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return lhs.space_id < rhs.space_id; + } + if (!(lhs.depend_schema == rhs.depend_schema)) { + return lhs.depend_schema < rhs.depend_schema; + } + if (!(lhs.fields == rhs.fields)) { + return lhs.fields < rhs.fields; + } + return false; +} + +const ::nebula::cpp2::SchemaID& FTIndex::get_depend_schema() const& { + return depend_schema; +} + + ::nebula::cpp2::SchemaID FTIndex::get_depend_schema() && { + return std::move(depend_schema); +} + +const ::std::vector<::std::string>& FTIndex::get_fields() const& { + return fields; +} + +::std::vector<::std::string> FTIndex::get_fields() && { + return std::move(fields); +} + + +void swap(FTIndex& a, FTIndex& b) { + using ::std::swap; + swap(a.space_id_ref().value(), b.space_id_ref().value()); + swap(a.depend_schema_ref().value(), b.depend_schema_ref().value()); + swap(a.fields_ref().value(), b.fields_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void FTIndex::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t FTIndex::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t FTIndex::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t FTIndex::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void FTIndex::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t FTIndex::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t FTIndex::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t FTIndex::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + FTIndex, + ::apache::thrift::type_class::variant, + ::nebula::cpp2::SchemaID>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + FTIndex, + ::apache::thrift::type_class::variant, + ::nebula::cpp2::SchemaID>, + "inconsistent use of nimble option"); + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::CreateFTIndexReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::CreateFTIndexReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +CreateFTIndexReq::CreateFTIndexReq(apache::thrift::FragileConstructor, ::std::string fulltext_index_name__arg, ::nebula::meta::cpp2::FTIndex index__arg) : + fulltext_index_name(std::move(fulltext_index_name__arg)), + index(std::move(index__arg)) { + __isset.fulltext_index_name = true; + __isset.index = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void CreateFTIndexReq::__clear() { + // clear all fields + fulltext_index_name = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); + index.__clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool CreateFTIndexReq::operator==(const CreateFTIndexReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!apache::thrift::StringTraits::isEqual(lhs.fulltext_index_name, rhs.fulltext_index_name)) { + return false; + } + if (!(lhs.index == rhs.index)) { + return false; + } + return true; +} + +bool CreateFTIndexReq::operator<(const CreateFTIndexReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!apache::thrift::StringTraits::isEqual(lhs.fulltext_index_name, rhs.fulltext_index_name)) { + return apache::thrift::StringTraits::isLess(lhs.fulltext_index_name, rhs.fulltext_index_name); + } + if (!(lhs.index == rhs.index)) { + return lhs.index < rhs.index; + } + return false; +} + +const ::nebula::meta::cpp2::FTIndex& CreateFTIndexReq::get_index() const& { + return index; +} + + ::nebula::meta::cpp2::FTIndex CreateFTIndexReq::get_index() && { + return std::move(index); +} + + +void swap(CreateFTIndexReq& a, CreateFTIndexReq& b) { + using ::std::swap; + swap(a.fulltext_index_name_ref().value(), b.fulltext_index_name_ref().value()); + swap(a.index_ref().value(), b.index_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void CreateFTIndexReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t CreateFTIndexReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t CreateFTIndexReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t CreateFTIndexReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void CreateFTIndexReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t CreateFTIndexReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t CreateFTIndexReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t CreateFTIndexReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + CreateFTIndexReq, + ::apache::thrift::type_class::structure, + ::nebula::meta::cpp2::FTIndex>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + CreateFTIndexReq, + ::apache::thrift::type_class::structure, + ::nebula::meta::cpp2::FTIndex>, + "inconsistent use of nimble option"); + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::DropFTIndexReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::DropFTIndexReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +DropFTIndexReq::DropFTIndexReq(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, ::std::string fulltext_index_name__arg) : + space_id(std::move(space_id__arg)), + fulltext_index_name(std::move(fulltext_index_name__arg)) { + __isset.space_id = true; + __isset.fulltext_index_name = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void DropFTIndexReq::__clear() { + // clear all fields + space_id = 0; + fulltext_index_name = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool DropFTIndexReq::operator==(const DropFTIndexReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return false; + } + if (!apache::thrift::StringTraits::isEqual(lhs.fulltext_index_name, rhs.fulltext_index_name)) { + return false; + } + return true; +} + +bool DropFTIndexReq::operator<(const DropFTIndexReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return lhs.space_id < rhs.space_id; + } + if (!apache::thrift::StringTraits::isEqual(lhs.fulltext_index_name, rhs.fulltext_index_name)) { + return apache::thrift::StringTraits::isLess(lhs.fulltext_index_name, rhs.fulltext_index_name); + } + return false; +} + + +void swap(DropFTIndexReq& a, DropFTIndexReq& b) { + using ::std::swap; + swap(a.space_id_ref().value(), b.space_id_ref().value()); + swap(a.fulltext_index_name_ref().value(), b.fulltext_index_name_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void DropFTIndexReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t DropFTIndexReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t DropFTIndexReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t DropFTIndexReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void DropFTIndexReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t DropFTIndexReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t DropFTIndexReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t DropFTIndexReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::ListFTIndexesReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::ListFTIndexesReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +ListFTIndexesReq::ListFTIndexesReq(apache::thrift::FragileConstructor) {} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void ListFTIndexesReq::__clear() { + // clear all fields +} + +bool ListFTIndexesReq::operator==(const ListFTIndexesReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + return true; +} + +bool ListFTIndexesReq::operator<(const ListFTIndexesReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + return false; +} + + +void swap(ListFTIndexesReq& a, ListFTIndexesReq& b) { + using ::std::swap; + (void)a; + (void)b; +} + +template void ListFTIndexesReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t ListFTIndexesReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t ListFTIndexesReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t ListFTIndexesReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void ListFTIndexesReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t ListFTIndexesReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t ListFTIndexesReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t ListFTIndexesReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::ListFTIndexesResp>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::ListFTIndexesResp>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +ListFTIndexesResp::ListFTIndexesResp(apache::thrift::FragileConstructor, ::nebula::cpp2::ErrorCode code__arg, nebula::HostAddr leader__arg, std::unordered_map<::std::string, ::nebula::meta::cpp2::FTIndex> indexes__arg) : + code(std::move(code__arg)), + leader(std::move(leader__arg)), + indexes(std::move(indexes__arg)) { + __isset.code = true; + __isset.leader = true; + __isset.indexes = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void ListFTIndexesResp::__clear() { + // clear all fields + code = ::nebula::cpp2::ErrorCode::SUCCEEDED; + leader.__clear(); + indexes.clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool ListFTIndexesResp::operator==(const ListFTIndexesResp& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.code == rhs.code)) { + return false; + } + if (!(lhs.leader == rhs.leader)) { + return false; + } + if (!(lhs.indexes == rhs.indexes)) { + return false; + } + return true; +} + +const nebula::HostAddr& ListFTIndexesResp::get_leader() const& { + return leader; +} + +nebula::HostAddr ListFTIndexesResp::get_leader() && { + return std::move(leader); +} + +const std::unordered_map<::std::string, ::nebula::meta::cpp2::FTIndex>& ListFTIndexesResp::get_indexes() const& { + return indexes; +} + +std::unordered_map<::std::string, ::nebula::meta::cpp2::FTIndex> ListFTIndexesResp::get_indexes() && { + return std::move(indexes); +} + + +void swap(ListFTIndexesResp& a, ListFTIndexesResp& b) { + using ::std::swap; + swap(a.code_ref().value(), b.code_ref().value()); + swap(a.leader_ref().value(), b.leader_ref().value()); + swap(a.indexes_ref().value(), b.indexes_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void ListFTIndexesResp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t ListFTIndexesResp::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t ListFTIndexesResp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t ListFTIndexesResp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void ListFTIndexesResp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t ListFTIndexesResp::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t ListFTIndexesResp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t ListFTIndexesResp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + ListFTIndexesResp, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + ListFTIndexesResp, + ::apache::thrift::type_class::map<::apache::thrift::type_class::binary, ::apache::thrift::type_class::structure>, + std::unordered_map<::std::string, ::nebula::meta::cpp2::FTIndex>>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + ListFTIndexesResp, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + ListFTIndexesResp, + ::apache::thrift::type_class::map<::apache::thrift::type_class::binary, ::apache::thrift::type_class::structure>, + std::unordered_map<::std::string, ::nebula::meta::cpp2::FTIndex>>, + "inconsistent use of nimble option"); + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::QueryDesc>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::QueryDesc>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +QueryDesc::QueryDesc() : + start_time(0), + status(static_cast< ::nebula::meta::cpp2::QueryStatus>(0)), + duration(0) {} +THRIFT_IGNORE_ISSET_USE_WARNING_END + + +QueryDesc::~QueryDesc() {} + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +QueryDesc::QueryDesc(apache::thrift::FragileConstructor, ::nebula::cpp2::Timestamp start_time__arg, ::nebula::meta::cpp2::QueryStatus status__arg, int64_t duration__arg, ::std::string query__arg, nebula::HostAddr graph_addr__arg) : + start_time(std::move(start_time__arg)), + status(std::move(status__arg)), + duration(std::move(duration__arg)), + query(std::move(query__arg)), + graph_addr(std::move(graph_addr__arg)) { + __isset.start_time = true; + __isset.status = true; + __isset.duration = true; + __isset.query = true; + __isset.graph_addr = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void QueryDesc::__clear() { + // clear all fields + start_time = 0; + status = static_cast< ::nebula::meta::cpp2::QueryStatus>(0); + duration = 0; + query = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); + graph_addr.__clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool QueryDesc::operator==(const QueryDesc& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.start_time == rhs.start_time)) { + return false; + } + if (!(lhs.status == rhs.status)) { + return false; + } + if (!(lhs.duration == rhs.duration)) { + return false; + } + if (!apache::thrift::StringTraits::isEqual(lhs.query, rhs.query)) { + return false; + } + if (!(lhs.graph_addr == rhs.graph_addr)) { + return false; + } + return true; +} + +bool QueryDesc::operator<(const QueryDesc& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.start_time == rhs.start_time)) { + return lhs.start_time < rhs.start_time; + } + if (!(lhs.status == rhs.status)) { + return lhs.status < rhs.status; + } + if (!(lhs.duration == rhs.duration)) { + return lhs.duration < rhs.duration; + } + if (!apache::thrift::StringTraits::isEqual(lhs.query, rhs.query)) { + return apache::thrift::StringTraits::isLess(lhs.query, rhs.query); + } + if (!(lhs.graph_addr == rhs.graph_addr)) { + return lhs.graph_addr < rhs.graph_addr; + } + return false; +} + +const nebula::HostAddr& QueryDesc::get_graph_addr() const& { + return graph_addr; +} + +nebula::HostAddr QueryDesc::get_graph_addr() && { + return std::move(graph_addr); +} + + +void swap(QueryDesc& a, QueryDesc& b) { + using ::std::swap; + swap(a.start_time_ref().value(), b.start_time_ref().value()); + swap(a.status_ref().value(), b.status_ref().value()); + swap(a.duration_ref().value(), b.duration_ref().value()); + swap(a.query_ref().value(), b.query_ref().value()); + swap(a.graph_addr_ref().value(), b.graph_addr_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void QueryDesc::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t QueryDesc::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t QueryDesc::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t QueryDesc::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void QueryDesc::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t QueryDesc::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t QueryDesc::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t QueryDesc::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + QueryDesc, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + QueryDesc, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of nimble option"); + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::Session>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::Session>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +Session::Session() : + session_id(0), + create_time(0), + update_time(0), + timezone(0) {} +THRIFT_IGNORE_ISSET_USE_WARNING_END + + +Session::~Session() {} + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +Session::Session(apache::thrift::FragileConstructor, ::nebula::cpp2::SessionID session_id__arg, ::nebula::cpp2::Timestamp create_time__arg, ::nebula::cpp2::Timestamp update_time__arg, ::std::string user_name__arg, ::std::string space_name__arg, nebula::HostAddr graph_addr__arg, int32_t timezone__arg, ::std::string client_ip__arg, std::unordered_map<::std::string, nebula::Value> configs__arg, std::unordered_map< ::nebula::cpp2::ExecutionPlanID, ::nebula::meta::cpp2::QueryDesc> queries__arg) : + session_id(std::move(session_id__arg)), + create_time(std::move(create_time__arg)), + update_time(std::move(update_time__arg)), + user_name(std::move(user_name__arg)), + space_name(std::move(space_name__arg)), + graph_addr(std::move(graph_addr__arg)), + timezone(std::move(timezone__arg)), + client_ip(std::move(client_ip__arg)), + configs(std::move(configs__arg)), + queries(std::move(queries__arg)) { + __isset.session_id = true; + __isset.create_time = true; + __isset.update_time = true; + __isset.user_name = true; + __isset.space_name = true; + __isset.graph_addr = true; + __isset.timezone = true; + __isset.client_ip = true; + __isset.configs = true; + __isset.queries = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void Session::__clear() { + // clear all fields + session_id = 0; + create_time = 0; + update_time = 0; + user_name = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); + space_name = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); + graph_addr.__clear(); + timezone = 0; + client_ip = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); + configs.clear(); + queries.clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool Session::operator==(const Session& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.session_id == rhs.session_id)) { + return false; + } + if (!(lhs.create_time == rhs.create_time)) { + return false; + } + if (!(lhs.update_time == rhs.update_time)) { + return false; + } + if (!apache::thrift::StringTraits::isEqual(lhs.user_name, rhs.user_name)) { + return false; + } + if (!apache::thrift::StringTraits::isEqual(lhs.space_name, rhs.space_name)) { + return false; + } + if (!(lhs.graph_addr == rhs.graph_addr)) { + return false; + } + if (!(lhs.timezone == rhs.timezone)) { + return false; + } + if (!apache::thrift::StringTraits::isEqual(lhs.client_ip, rhs.client_ip)) { + return false; + } + if (!(lhs.configs == rhs.configs)) { + return false; + } + if (!(lhs.queries == rhs.queries)) { + return false; + } + return true; +} + +const nebula::HostAddr& Session::get_graph_addr() const& { + return graph_addr; +} + +nebula::HostAddr Session::get_graph_addr() && { + return std::move(graph_addr); +} + +const std::unordered_map<::std::string, nebula::Value>& Session::get_configs() const& { + return configs; +} + +std::unordered_map<::std::string, nebula::Value> Session::get_configs() && { + return std::move(configs); +} + +const std::unordered_map< ::nebula::cpp2::ExecutionPlanID, ::nebula::meta::cpp2::QueryDesc>& Session::get_queries() const& { + return queries; +} + +std::unordered_map< ::nebula::cpp2::ExecutionPlanID, ::nebula::meta::cpp2::QueryDesc> Session::get_queries() && { + return std::move(queries); +} + + +void swap(Session& a, Session& b) { + using ::std::swap; + swap(a.session_id_ref().value(), b.session_id_ref().value()); + swap(a.create_time_ref().value(), b.create_time_ref().value()); + swap(a.update_time_ref().value(), b.update_time_ref().value()); + swap(a.user_name_ref().value(), b.user_name_ref().value()); + swap(a.space_name_ref().value(), b.space_name_ref().value()); + swap(a.graph_addr_ref().value(), b.graph_addr_ref().value()); + swap(a.timezone_ref().value(), b.timezone_ref().value()); + swap(a.client_ip_ref().value(), b.client_ip_ref().value()); + swap(a.configs_ref().value(), b.configs_ref().value()); + swap(a.queries_ref().value(), b.queries_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void Session::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t Session::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t Session::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t Session::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void Session::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t Session::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t Session::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t Session::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + Session, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + Session, + ::apache::thrift::type_class::map<::apache::thrift::type_class::binary, ::apache::thrift::type_class::variant>, + std::unordered_map<::std::string, nebula::Value>>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + Session, + ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::structure>, + std::unordered_map< ::nebula::cpp2::ExecutionPlanID, ::nebula::meta::cpp2::QueryDesc>>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + Session, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + Session, + ::apache::thrift::type_class::map<::apache::thrift::type_class::binary, ::apache::thrift::type_class::variant>, + std::unordered_map<::std::string, nebula::Value>>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + Session, + ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::structure>, + std::unordered_map< ::nebula::cpp2::ExecutionPlanID, ::nebula::meta::cpp2::QueryDesc>>, + "inconsistent use of nimble option"); + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::CreateSessionReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::CreateSessionReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +CreateSessionReq::CreateSessionReq(apache::thrift::FragileConstructor, ::std::string user__arg, nebula::HostAddr graph_addr__arg, ::std::string client_ip__arg) : + user(std::move(user__arg)), + graph_addr(std::move(graph_addr__arg)), + client_ip(std::move(client_ip__arg)) { + __isset.user = true; + __isset.graph_addr = true; + __isset.client_ip = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void CreateSessionReq::__clear() { + // clear all fields + user = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); + graph_addr.__clear(); + client_ip = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool CreateSessionReq::operator==(const CreateSessionReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!apache::thrift::StringTraits::isEqual(lhs.user, rhs.user)) { + return false; + } + if (!(lhs.graph_addr == rhs.graph_addr)) { + return false; + } + if (!apache::thrift::StringTraits::isEqual(lhs.client_ip, rhs.client_ip)) { + return false; + } + return true; +} + +bool CreateSessionReq::operator<(const CreateSessionReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!apache::thrift::StringTraits::isEqual(lhs.user, rhs.user)) { + return apache::thrift::StringTraits::isLess(lhs.user, rhs.user); + } + if (!(lhs.graph_addr == rhs.graph_addr)) { + return lhs.graph_addr < rhs.graph_addr; + } + if (!apache::thrift::StringTraits::isEqual(lhs.client_ip, rhs.client_ip)) { + return apache::thrift::StringTraits::isLess(lhs.client_ip, rhs.client_ip); + } + return false; +} + +const nebula::HostAddr& CreateSessionReq::get_graph_addr() const& { + return graph_addr; +} + +nebula::HostAddr CreateSessionReq::get_graph_addr() && { + return std::move(graph_addr); +} + + +void swap(CreateSessionReq& a, CreateSessionReq& b) { + using ::std::swap; + swap(a.user_ref().value(), b.user_ref().value()); + swap(a.graph_addr_ref().value(), b.graph_addr_ref().value()); + swap(a.client_ip_ref().value(), b.client_ip_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void CreateSessionReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t CreateSessionReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t CreateSessionReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t CreateSessionReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void CreateSessionReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t CreateSessionReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t CreateSessionReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t CreateSessionReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + CreateSessionReq, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + CreateSessionReq, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of nimble option"); + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::CreateSessionResp>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::CreateSessionResp>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +CreateSessionResp::CreateSessionResp(apache::thrift::FragileConstructor, ::nebula::cpp2::ErrorCode code__arg, nebula::HostAddr leader__arg, ::nebula::meta::cpp2::Session session__arg) : + code(std::move(code__arg)), + leader(std::move(leader__arg)), + session(std::move(session__arg)) { + __isset.code = true; + __isset.leader = true; + __isset.session = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void CreateSessionResp::__clear() { + // clear all fields + code = ::nebula::cpp2::ErrorCode::SUCCEEDED; + leader.__clear(); + session.__clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool CreateSessionResp::operator==(const CreateSessionResp& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.code == rhs.code)) { + return false; + } + if (!(lhs.leader == rhs.leader)) { + return false; + } + if (!(lhs.session == rhs.session)) { + return false; + } + return true; +} + +const nebula::HostAddr& CreateSessionResp::get_leader() const& { + return leader; +} + +nebula::HostAddr CreateSessionResp::get_leader() && { + return std::move(leader); +} + +const ::nebula::meta::cpp2::Session& CreateSessionResp::get_session() const& { + return session; +} + + ::nebula::meta::cpp2::Session CreateSessionResp::get_session() && { + return std::move(session); +} + + +void swap(CreateSessionResp& a, CreateSessionResp& b) { + using ::std::swap; + swap(a.code_ref().value(), b.code_ref().value()); + swap(a.leader_ref().value(), b.leader_ref().value()); + swap(a.session_ref().value(), b.session_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void CreateSessionResp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t CreateSessionResp::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t CreateSessionResp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t CreateSessionResp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void CreateSessionResp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t CreateSessionResp::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t CreateSessionResp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t CreateSessionResp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + CreateSessionResp, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + CreateSessionResp, + ::apache::thrift::type_class::structure, + ::nebula::meta::cpp2::Session>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + CreateSessionResp, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + CreateSessionResp, + ::apache::thrift::type_class::structure, + ::nebula::meta::cpp2::Session>, + "inconsistent use of nimble option"); + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::UpdateSessionsReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::UpdateSessionsReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +UpdateSessionsReq::UpdateSessionsReq(apache::thrift::FragileConstructor, ::std::vector< ::nebula::meta::cpp2::Session> sessions__arg) : + sessions(std::move(sessions__arg)) { + __isset.sessions = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void UpdateSessionsReq::__clear() { + // clear all fields + sessions.clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool UpdateSessionsReq::operator==(const UpdateSessionsReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.sessions == rhs.sessions)) { + return false; + } + return true; +} + +const ::std::vector< ::nebula::meta::cpp2::Session>& UpdateSessionsReq::get_sessions() const& { + return sessions; +} + +::std::vector< ::nebula::meta::cpp2::Session> UpdateSessionsReq::get_sessions() && { + return std::move(sessions); +} + + +void swap(UpdateSessionsReq& a, UpdateSessionsReq& b) { + using ::std::swap; + swap(a.sessions_ref().value(), b.sessions_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void UpdateSessionsReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t UpdateSessionsReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t UpdateSessionsReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t UpdateSessionsReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void UpdateSessionsReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t UpdateSessionsReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t UpdateSessionsReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t UpdateSessionsReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + UpdateSessionsReq, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector< ::nebula::meta::cpp2::Session>>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + UpdateSessionsReq, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector< ::nebula::meta::cpp2::Session>>, + "inconsistent use of nimble option"); + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::UpdateSessionsResp>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::UpdateSessionsResp>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +UpdateSessionsResp::UpdateSessionsResp(apache::thrift::FragileConstructor, ::nebula::cpp2::ErrorCode code__arg, nebula::HostAddr leader__arg, std::unordered_map< ::nebula::cpp2::SessionID, std::unordered_map< ::nebula::cpp2::ExecutionPlanID, ::nebula::meta::cpp2::QueryDesc>> killed_queries__arg) : + code(std::move(code__arg)), + leader(std::move(leader__arg)), + killed_queries(std::move(killed_queries__arg)) { + __isset.code = true; + __isset.leader = true; + __isset.killed_queries = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void UpdateSessionsResp::__clear() { + // clear all fields + code = ::nebula::cpp2::ErrorCode::SUCCEEDED; + leader.__clear(); + killed_queries.clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool UpdateSessionsResp::operator==(const UpdateSessionsResp& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.code == rhs.code)) { + return false; + } + if (!(lhs.leader == rhs.leader)) { + return false; + } + if (!(lhs.killed_queries == rhs.killed_queries)) { + return false; + } + return true; +} + +const nebula::HostAddr& UpdateSessionsResp::get_leader() const& { + return leader; +} + +nebula::HostAddr UpdateSessionsResp::get_leader() && { + return std::move(leader); +} + +const std::unordered_map< ::nebula::cpp2::SessionID, std::unordered_map< ::nebula::cpp2::ExecutionPlanID, ::nebula::meta::cpp2::QueryDesc>>& UpdateSessionsResp::get_killed_queries() const& { + return killed_queries; +} + +std::unordered_map< ::nebula::cpp2::SessionID, std::unordered_map< ::nebula::cpp2::ExecutionPlanID, ::nebula::meta::cpp2::QueryDesc>> UpdateSessionsResp::get_killed_queries() && { + return std::move(killed_queries); +} + + +void swap(UpdateSessionsResp& a, UpdateSessionsResp& b) { + using ::std::swap; + swap(a.code_ref().value(), b.code_ref().value()); + swap(a.leader_ref().value(), b.leader_ref().value()); + swap(a.killed_queries_ref().value(), b.killed_queries_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void UpdateSessionsResp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t UpdateSessionsResp::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t UpdateSessionsResp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t UpdateSessionsResp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void UpdateSessionsResp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t UpdateSessionsResp::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t UpdateSessionsResp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t UpdateSessionsResp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + UpdateSessionsResp, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + UpdateSessionsResp, + ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::structure>>, + std::unordered_map< ::nebula::cpp2::SessionID, std::unordered_map< ::nebula::cpp2::ExecutionPlanID, ::nebula::meta::cpp2::QueryDesc>>>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + UpdateSessionsResp, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + UpdateSessionsResp, + ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::structure>>, + std::unordered_map< ::nebula::cpp2::SessionID, std::unordered_map< ::nebula::cpp2::ExecutionPlanID, ::nebula::meta::cpp2::QueryDesc>>>, + "inconsistent use of nimble option"); + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::ListSessionsReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::ListSessionsReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +ListSessionsReq::ListSessionsReq(apache::thrift::FragileConstructor) {} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void ListSessionsReq::__clear() { + // clear all fields +} + +bool ListSessionsReq::operator==(const ListSessionsReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + return true; +} + +bool ListSessionsReq::operator<(const ListSessionsReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + return false; +} + + +void swap(ListSessionsReq& a, ListSessionsReq& b) { + using ::std::swap; + (void)a; + (void)b; +} + +template void ListSessionsReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t ListSessionsReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t ListSessionsReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t ListSessionsReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void ListSessionsReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t ListSessionsReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t ListSessionsReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t ListSessionsReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::ListSessionsResp>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::ListSessionsResp>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +ListSessionsResp::ListSessionsResp(apache::thrift::FragileConstructor, ::nebula::cpp2::ErrorCode code__arg, nebula::HostAddr leader__arg, ::std::vector< ::nebula::meta::cpp2::Session> sessions__arg) : + code(std::move(code__arg)), + leader(std::move(leader__arg)), + sessions(std::move(sessions__arg)) { + __isset.code = true; + __isset.leader = true; + __isset.sessions = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void ListSessionsResp::__clear() { + // clear all fields + code = ::nebula::cpp2::ErrorCode::SUCCEEDED; + leader.__clear(); + sessions.clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool ListSessionsResp::operator==(const ListSessionsResp& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.code == rhs.code)) { + return false; + } + if (!(lhs.leader == rhs.leader)) { + return false; + } + if (!(lhs.sessions == rhs.sessions)) { + return false; + } + return true; +} + +const nebula::HostAddr& ListSessionsResp::get_leader() const& { + return leader; +} + +nebula::HostAddr ListSessionsResp::get_leader() && { + return std::move(leader); +} + +const ::std::vector< ::nebula::meta::cpp2::Session>& ListSessionsResp::get_sessions() const& { + return sessions; +} + +::std::vector< ::nebula::meta::cpp2::Session> ListSessionsResp::get_sessions() && { + return std::move(sessions); +} + + +void swap(ListSessionsResp& a, ListSessionsResp& b) { + using ::std::swap; + swap(a.code_ref().value(), b.code_ref().value()); + swap(a.leader_ref().value(), b.leader_ref().value()); + swap(a.sessions_ref().value(), b.sessions_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void ListSessionsResp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t ListSessionsResp::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t ListSessionsResp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t ListSessionsResp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void ListSessionsResp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t ListSessionsResp::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t ListSessionsResp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t ListSessionsResp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + ListSessionsResp, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + ListSessionsResp, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector< ::nebula::meta::cpp2::Session>>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + ListSessionsResp, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + ListSessionsResp, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector< ::nebula::meta::cpp2::Session>>, + "inconsistent use of nimble option"); + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::GetSessionReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::GetSessionReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +GetSessionReq::GetSessionReq(apache::thrift::FragileConstructor, ::nebula::cpp2::SessionID session_id__arg) : + session_id(std::move(session_id__arg)) { + __isset.session_id = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void GetSessionReq::__clear() { + // clear all fields + session_id = 0; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool GetSessionReq::operator==(const GetSessionReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.session_id == rhs.session_id)) { + return false; + } + return true; +} + +bool GetSessionReq::operator<(const GetSessionReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.session_id == rhs.session_id)) { + return lhs.session_id < rhs.session_id; + } + return false; +} + + +void swap(GetSessionReq& a, GetSessionReq& b) { + using ::std::swap; + swap(a.session_id_ref().value(), b.session_id_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void GetSessionReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t GetSessionReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t GetSessionReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t GetSessionReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void GetSessionReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t GetSessionReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t GetSessionReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t GetSessionReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::GetSessionResp>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::GetSessionResp>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +GetSessionResp::GetSessionResp(apache::thrift::FragileConstructor, ::nebula::cpp2::ErrorCode code__arg, nebula::HostAddr leader__arg, ::nebula::meta::cpp2::Session session__arg) : + code(std::move(code__arg)), + leader(std::move(leader__arg)), + session(std::move(session__arg)) { + __isset.code = true; + __isset.leader = true; + __isset.session = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void GetSessionResp::__clear() { + // clear all fields + code = ::nebula::cpp2::ErrorCode::SUCCEEDED; + leader.__clear(); + session.__clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool GetSessionResp::operator==(const GetSessionResp& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.code == rhs.code)) { + return false; + } + if (!(lhs.leader == rhs.leader)) { + return false; + } + if (!(lhs.session == rhs.session)) { + return false; + } + return true; +} + +const nebula::HostAddr& GetSessionResp::get_leader() const& { + return leader; +} + +nebula::HostAddr GetSessionResp::get_leader() && { + return std::move(leader); +} + +const ::nebula::meta::cpp2::Session& GetSessionResp::get_session() const& { + return session; +} + + ::nebula::meta::cpp2::Session GetSessionResp::get_session() && { + return std::move(session); +} + + +void swap(GetSessionResp& a, GetSessionResp& b) { + using ::std::swap; + swap(a.code_ref().value(), b.code_ref().value()); + swap(a.leader_ref().value(), b.leader_ref().value()); + swap(a.session_ref().value(), b.session_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void GetSessionResp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t GetSessionResp::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t GetSessionResp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t GetSessionResp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void GetSessionResp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t GetSessionResp::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t GetSessionResp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t GetSessionResp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + GetSessionResp, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + GetSessionResp, + ::apache::thrift::type_class::structure, + ::nebula::meta::cpp2::Session>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + GetSessionResp, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + GetSessionResp, + ::apache::thrift::type_class::structure, + ::nebula::meta::cpp2::Session>, + "inconsistent use of nimble option"); + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::RemoveSessionReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::RemoveSessionReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +RemoveSessionReq::RemoveSessionReq(apache::thrift::FragileConstructor, ::nebula::cpp2::SessionID session_id__arg) : + session_id(std::move(session_id__arg)) { + __isset.session_id = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void RemoveSessionReq::__clear() { + // clear all fields + session_id = 0; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool RemoveSessionReq::operator==(const RemoveSessionReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.session_id == rhs.session_id)) { + return false; + } + return true; +} + +bool RemoveSessionReq::operator<(const RemoveSessionReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.session_id == rhs.session_id)) { + return lhs.session_id < rhs.session_id; + } + return false; +} + + +void swap(RemoveSessionReq& a, RemoveSessionReq& b) { + using ::std::swap; + swap(a.session_id_ref().value(), b.session_id_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void RemoveSessionReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t RemoveSessionReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t RemoveSessionReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t RemoveSessionReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void RemoveSessionReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t RemoveSessionReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t RemoveSessionReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t RemoveSessionReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::KillQueryReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::KillQueryReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +KillQueryReq::KillQueryReq(apache::thrift::FragileConstructor, std::unordered_map< ::nebula::cpp2::SessionID, std::unordered_set< ::nebula::cpp2::ExecutionPlanID>> kill_queries__arg) : + kill_queries(std::move(kill_queries__arg)) { + __isset.kill_queries = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void KillQueryReq::__clear() { + // clear all fields + kill_queries.clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool KillQueryReq::operator==(const KillQueryReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.kill_queries == rhs.kill_queries)) { + return false; + } + return true; +} + +const std::unordered_map< ::nebula::cpp2::SessionID, std::unordered_set< ::nebula::cpp2::ExecutionPlanID>>& KillQueryReq::get_kill_queries() const& { + return kill_queries; +} + +std::unordered_map< ::nebula::cpp2::SessionID, std::unordered_set< ::nebula::cpp2::ExecutionPlanID>> KillQueryReq::get_kill_queries() && { + return std::move(kill_queries); +} + + +void swap(KillQueryReq& a, KillQueryReq& b) { + using ::std::swap; + swap(a.kill_queries_ref().value(), b.kill_queries_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void KillQueryReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t KillQueryReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t KillQueryReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t KillQueryReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void KillQueryReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t KillQueryReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t KillQueryReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t KillQueryReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::ReportTaskReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::ReportTaskReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +ReportTaskReq::ReportTaskReq(apache::thrift::FragileConstructor, ::nebula::cpp2::ErrorCode code__arg, int32_t job_id__arg, int32_t task_id__arg, ::nebula::meta::cpp2::StatsItem stats__arg) : + code(std::move(code__arg)), + job_id(std::move(job_id__arg)), + task_id(std::move(task_id__arg)), + stats(std::move(stats__arg)) { + __isset.code = true; + __isset.job_id = true; + __isset.task_id = true; + __isset.stats = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void ReportTaskReq::__clear() { + // clear all fields + code = ::nebula::cpp2::ErrorCode::SUCCEEDED; + job_id = 0; + task_id = 0; + stats.__clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool ReportTaskReq::operator==(const ReportTaskReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.code == rhs.code)) { + return false; + } + if (!(lhs.job_id == rhs.job_id)) { + return false; + } + if (!(lhs.task_id == rhs.task_id)) { + return false; + } + if (lhs.stats_ref() != rhs.stats_ref()) { + return false; + } + return true; +} + +const ::nebula::meta::cpp2::StatsItem* ReportTaskReq::get_stats() const& { + return stats_ref().has_value() ? std::addressof(stats) : nullptr; +} + + ::nebula::meta::cpp2::StatsItem* ReportTaskReq::get_stats() & { + return stats_ref().has_value() ? std::addressof(stats) : nullptr; +} + + +void swap(ReportTaskReq& a, ReportTaskReq& b) { + using ::std::swap; + swap(a.code_ref().value(), b.code_ref().value()); + swap(a.job_id_ref().value(), b.job_id_ref().value()); + swap(a.task_id_ref().value(), b.task_id_ref().value()); + swap(a.stats_ref().value_unchecked(), b.stats_ref().value_unchecked()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void ReportTaskReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t ReportTaskReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t ReportTaskReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t ReportTaskReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void ReportTaskReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t ReportTaskReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t ReportTaskReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t ReportTaskReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + ReportTaskReq, + ::apache::thrift::type_class::structure, + ::nebula::meta::cpp2::StatsItem>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + ReportTaskReq, + ::apache::thrift::type_class::structure, + ::nebula::meta::cpp2::StatsItem>, + "inconsistent use of nimble option"); + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::ListClusterInfoResp>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::ListClusterInfoResp>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +ListClusterInfoResp::ListClusterInfoResp(apache::thrift::FragileConstructor, ::nebula::cpp2::ErrorCode code__arg, nebula::HostAddr leader__arg, ::std::vector meta_servers__arg, ::std::vector< ::nebula::cpp2::NodeInfo> storage_servers__arg) : + code(std::move(code__arg)), + leader(std::move(leader__arg)), + meta_servers(std::move(meta_servers__arg)), + storage_servers(std::move(storage_servers__arg)) { + __isset.code = true; + __isset.leader = true; + __isset.meta_servers = true; + __isset.storage_servers = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void ListClusterInfoResp::__clear() { + // clear all fields + code = ::nebula::cpp2::ErrorCode::SUCCEEDED; + leader.__clear(); + meta_servers.clear(); + storage_servers.clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool ListClusterInfoResp::operator==(const ListClusterInfoResp& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.code == rhs.code)) { + return false; + } + if (!(lhs.leader == rhs.leader)) { + return false; + } + if (!(lhs.meta_servers == rhs.meta_servers)) { + return false; + } + if (!(lhs.storage_servers == rhs.storage_servers)) { + return false; + } + return true; +} + +bool ListClusterInfoResp::operator<(const ListClusterInfoResp& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.code == rhs.code)) { + return lhs.code < rhs.code; + } + if (!(lhs.leader == rhs.leader)) { + return lhs.leader < rhs.leader; + } + if (!(lhs.meta_servers == rhs.meta_servers)) { + return lhs.meta_servers < rhs.meta_servers; + } + if (!(lhs.storage_servers == rhs.storage_servers)) { + return lhs.storage_servers < rhs.storage_servers; + } + return false; +} + +const nebula::HostAddr& ListClusterInfoResp::get_leader() const& { + return leader; +} + +nebula::HostAddr ListClusterInfoResp::get_leader() && { + return std::move(leader); +} + +const ::std::vector& ListClusterInfoResp::get_meta_servers() const& { + return meta_servers; +} + +::std::vector ListClusterInfoResp::get_meta_servers() && { + return std::move(meta_servers); +} + +const ::std::vector< ::nebula::cpp2::NodeInfo>& ListClusterInfoResp::get_storage_servers() const& { + return storage_servers; +} + +::std::vector< ::nebula::cpp2::NodeInfo> ListClusterInfoResp::get_storage_servers() && { + return std::move(storage_servers); +} + + +void swap(ListClusterInfoResp& a, ListClusterInfoResp& b) { + using ::std::swap; + swap(a.code_ref().value(), b.code_ref().value()); + swap(a.leader_ref().value(), b.leader_ref().value()); + swap(a.meta_servers_ref().value(), b.meta_servers_ref().value()); + swap(a.storage_servers_ref().value(), b.storage_servers_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void ListClusterInfoResp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t ListClusterInfoResp::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t ListClusterInfoResp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t ListClusterInfoResp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void ListClusterInfoResp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t ListClusterInfoResp::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t ListClusterInfoResp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t ListClusterInfoResp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + ListClusterInfoResp, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + ListClusterInfoResp, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + ListClusterInfoResp, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector< ::nebula::cpp2::NodeInfo>>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + ListClusterInfoResp, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + ListClusterInfoResp, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + ListClusterInfoResp, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector< ::nebula::cpp2::NodeInfo>>, + "inconsistent use of nimble option"); + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::ListClusterInfoReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::ListClusterInfoReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +ListClusterInfoReq::ListClusterInfoReq(apache::thrift::FragileConstructor) {} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void ListClusterInfoReq::__clear() { + // clear all fields +} + +bool ListClusterInfoReq::operator==(const ListClusterInfoReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + return true; +} + +bool ListClusterInfoReq::operator<(const ListClusterInfoReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + return false; +} + + +void swap(ListClusterInfoReq& a, ListClusterInfoReq& b) { + using ::std::swap; + (void)a; + (void)b; +} + +template void ListClusterInfoReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t ListClusterInfoReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t ListClusterInfoReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t ListClusterInfoReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void ListClusterInfoReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t ListClusterInfoReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t ListClusterInfoReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t ListClusterInfoReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::GetMetaDirInfoResp>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::GetMetaDirInfoResp>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +GetMetaDirInfoResp::GetMetaDirInfoResp(apache::thrift::FragileConstructor, ::nebula::cpp2::ErrorCode code__arg, ::nebula::cpp2::DirInfo dir__arg) : + code(std::move(code__arg)), + dir(std::move(dir__arg)) { + __isset.code = true; + __isset.dir = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void GetMetaDirInfoResp::__clear() { + // clear all fields + code = ::nebula::cpp2::ErrorCode::SUCCEEDED; + dir.__clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool GetMetaDirInfoResp::operator==(const GetMetaDirInfoResp& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.code == rhs.code)) { + return false; + } + if (!(lhs.dir == rhs.dir)) { + return false; + } + return true; +} + +bool GetMetaDirInfoResp::operator<(const GetMetaDirInfoResp& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.code == rhs.code)) { + return lhs.code < rhs.code; + } + if (!(lhs.dir == rhs.dir)) { + return lhs.dir < rhs.dir; + } + return false; +} + +const ::nebula::cpp2::DirInfo& GetMetaDirInfoResp::get_dir() const& { + return dir; +} + + ::nebula::cpp2::DirInfo GetMetaDirInfoResp::get_dir() && { + return std::move(dir); +} + + +void swap(GetMetaDirInfoResp& a, GetMetaDirInfoResp& b) { + using ::std::swap; + swap(a.code_ref().value(), b.code_ref().value()); + swap(a.dir_ref().value(), b.dir_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void GetMetaDirInfoResp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t GetMetaDirInfoResp::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t GetMetaDirInfoResp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t GetMetaDirInfoResp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void GetMetaDirInfoResp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t GetMetaDirInfoResp::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t GetMetaDirInfoResp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t GetMetaDirInfoResp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + GetMetaDirInfoResp, + ::apache::thrift::type_class::structure, + ::nebula::cpp2::DirInfo>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + GetMetaDirInfoResp, + ::apache::thrift::type_class::structure, + ::nebula::cpp2::DirInfo>, + "inconsistent use of nimble option"); + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::GetMetaDirInfoReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::GetMetaDirInfoReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +GetMetaDirInfoReq::GetMetaDirInfoReq(apache::thrift::FragileConstructor) {} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void GetMetaDirInfoReq::__clear() { + // clear all fields +} + +bool GetMetaDirInfoReq::operator==(const GetMetaDirInfoReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + return true; +} + +bool GetMetaDirInfoReq::operator<(const GetMetaDirInfoReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + return false; +} + + +void swap(GetMetaDirInfoReq& a, GetMetaDirInfoReq& b) { + using ::std::swap; + (void)a; + (void)b; +} + +template void GetMetaDirInfoReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t GetMetaDirInfoReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t GetMetaDirInfoReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t GetMetaDirInfoReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void GetMetaDirInfoReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t GetMetaDirInfoReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t GetMetaDirInfoReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t GetMetaDirInfoReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::VerifyClientVersionResp>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::VerifyClientVersionResp>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +VerifyClientVersionResp::VerifyClientVersionResp(apache::thrift::FragileConstructor, ::nebula::cpp2::ErrorCode code__arg, nebula::HostAddr leader__arg, ::std::string error_msg__arg) : + code(std::move(code__arg)), + leader(std::move(leader__arg)), + error_msg(std::move(error_msg__arg)) { + __isset.code = true; + __isset.leader = true; + __isset.error_msg = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void VerifyClientVersionResp::__clear() { + // clear all fields + code = ::nebula::cpp2::ErrorCode::SUCCEEDED; + leader.__clear(); + error_msg = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool VerifyClientVersionResp::operator==(const VerifyClientVersionResp& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.code == rhs.code)) { + return false; + } + if (!(lhs.leader == rhs.leader)) { + return false; + } + if (lhs.error_msg_ref().has_value() != rhs.error_msg_ref().has_value()) { + return false; + } + if (lhs.error_msg_ref().has_value()) { + if (!apache::thrift::StringTraits::isEqual(lhs.error_msg, rhs.error_msg)) { + return false; + } + } + return true; +} + +bool VerifyClientVersionResp::operator<(const VerifyClientVersionResp& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.code == rhs.code)) { + return lhs.code < rhs.code; + } + if (!(lhs.leader == rhs.leader)) { + return lhs.leader < rhs.leader; + } + if (lhs.error_msg_ref().has_value() != rhs.error_msg_ref().has_value()) { + return lhs.error_msg_ref().has_value() < rhs.error_msg_ref().has_value(); + } + if (lhs.error_msg_ref().has_value()) { + if (!apache::thrift::StringTraits::isEqual(lhs.error_msg, rhs.error_msg)) { + return apache::thrift::StringTraits::isLess(lhs.error_msg, rhs.error_msg); + } + } + return false; +} + +const nebula::HostAddr& VerifyClientVersionResp::get_leader() const& { + return leader; +} + +nebula::HostAddr VerifyClientVersionResp::get_leader() && { + return std::move(leader); +} + + +void swap(VerifyClientVersionResp& a, VerifyClientVersionResp& b) { + using ::std::swap; + swap(a.code_ref().value(), b.code_ref().value()); + swap(a.leader_ref().value(), b.leader_ref().value()); + swap(a.error_msg_ref().value_unchecked(), b.error_msg_ref().value_unchecked()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void VerifyClientVersionResp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t VerifyClientVersionResp::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t VerifyClientVersionResp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t VerifyClientVersionResp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void VerifyClientVersionResp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t VerifyClientVersionResp::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t VerifyClientVersionResp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t VerifyClientVersionResp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + VerifyClientVersionResp, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + VerifyClientVersionResp, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of nimble option"); + +}}} // nebula::meta::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::meta::cpp2::VerifyClientVersionReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::meta::cpp2::VerifyClientVersionReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +VerifyClientVersionReq::VerifyClientVersionReq(apache::thrift::FragileConstructor, ::std::string version__arg) : + version(std::move(version__arg)) {} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void VerifyClientVersionReq::__clear() { + // clear all fields + version = apache::thrift::StringTraits< std::string>::fromStringLiteral("2.6.0"); +} + +bool VerifyClientVersionReq::operator==(const VerifyClientVersionReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!apache::thrift::StringTraits::isEqual(lhs.version, rhs.version)) { + return false; + } + return true; +} + +bool VerifyClientVersionReq::operator<(const VerifyClientVersionReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!apache::thrift::StringTraits::isEqual(lhs.version, rhs.version)) { + return apache::thrift::StringTraits::isLess(lhs.version, rhs.version); + } + return false; +} + + +void swap(VerifyClientVersionReq& a, VerifyClientVersionReq& b) { + using ::std::swap; + swap(a.version_ref().value(), b.version_ref().value()); +} + +template void VerifyClientVersionReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t VerifyClientVersionReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t VerifyClientVersionReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t VerifyClientVersionReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void VerifyClientVersionReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t VerifyClientVersionReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t VerifyClientVersionReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t VerifyClientVersionReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::meta::cpp2 diff --git a/src/interface/gen-cpp2/meta_types.h b/src/interface/gen-cpp2/meta_types.h new file mode 100644 index 00000000..f0402603 --- /dev/null +++ b/src/interface/gen-cpp2/meta_types.h @@ -0,0 +1,33986 @@ +/** + * Autogenerated by Thrift for meta.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#pragma once + +#include + + +#include "common_types.h" + +namespace apache { +namespace thrift { +namespace tag { +struct space_id; +struct tag_id; +struct edge_type; +struct index_id; +struct cluster_id; +struct type; +struct type_length; +struct geo_shape; +struct name; +struct type; +struct default_value; +struct nullable; +struct comment; +struct ttl_duration; +struct ttl_col; +struct comment; +struct columns; +struct schema_prop; +struct id; +struct name; +struct space_name; +struct partition_num; +struct replica_factor; +struct charset_name; +struct collate_name; +struct vid_type; +struct group_name; +struct isolation_level; +struct comment; +struct space_id; +struct properties; +struct tag_id; +struct tag_name; +struct version; +struct schema; +struct op; +struct schema; +struct edge_type; +struct edge_name; +struct version; +struct schema; +struct index_id; +struct index_name; +struct schema_id; +struct schema_name; +struct fields; +struct comment; +struct hostAddr; +struct status; +struct leader_parts; +struct all_parts; +struct role; +struct git_info_sha; +struct zone_name; +struct version; +struct account; +struct is_lock; +struct max_queries_per_hour; +struct max_updates_per_hour; +struct max_connections_per_hour; +struct max_user_connections; +struct user_id; +struct space_id; +struct role_type; +struct code; +struct id; +struct leader; +struct op; +struct cmd; +struct paras; +struct id; +struct cmd; +struct paras; +struct status; +struct start_time; +struct stop_time; +struct task_id; +struct host; +struct status; +struct start_time; +struct stop_time; +struct job_id; +struct job_id; +struct job_desc; +struct task_desc; +struct recovered_job_num; +struct code; +struct leader; +struct result; +struct part_id; +struct proportion; +struct tag_vertices; +struct edges; +struct space_vertices; +struct space_edges; +struct positive_part_correlativity; +struct negative_part_correlativity; +struct status; +struct properties; +struct if_not_exists; +struct old_space_name; +struct new_space_name; +struct space_name; +struct if_exists; +struct code; +struct leader; +struct spaces; +struct space_name; +struct code; +struct leader; +struct item; +struct space_id; +struct tag_name; +struct schema; +struct if_not_exists; +struct space_id; +struct tag_name; +struct tag_items; +struct schema_prop; +struct space_id; +struct tag_name; +struct if_exists; +struct space_id; +struct code; +struct leader; +struct tags; +struct space_id; +struct tag_name; +struct version; +struct code; +struct leader; +struct schema; +struct space_id; +struct edge_name; +struct schema; +struct if_not_exists; +struct space_id; +struct edge_name; +struct edge_items; +struct schema_prop; +struct space_id; +struct edge_name; +struct version; +struct code; +struct leader; +struct schema; +struct space_id; +struct edge_name; +struct if_exists; +struct space_id; +struct code; +struct leader; +struct edges; +struct type; +struct code; +struct leader; +struct hosts; +struct part_id; +struct leader; +struct peers; +struct losts; +struct space_id; +struct part_ids; +struct code; +struct leader; +struct parts; +struct space_id; +struct code; +struct leader; +struct parts; +struct terms; +struct segment; +struct pairs; +struct segment; +struct key; +struct code; +struct leader; +struct value; +struct segment; +struct keys; +struct code; +struct leader; +struct values; +struct segment; +struct key; +struct segment; +struct start; +struct end; +struct segment; +struct start; +struct end; +struct code; +struct leader; +struct values; +struct code; +struct leader; +struct cluster_id; +struct last_update_time_in_ms; +struct meta_version; +struct part_id; +struct term; +struct role; +struct host; +struct cluster_id; +struct leader_partIds; +struct git_info_sha; +struct version; +struct name; +struct type_length; +struct space_id; +struct index_name; +struct tag_name; +struct fields; +struct if_not_exists; +struct comment; +struct space_id; +struct index_name; +struct if_exists; +struct space_id; +struct index_name; +struct code; +struct leader; +struct item; +struct space_id; +struct code; +struct leader; +struct items; +struct space_id; +struct index_name; +struct edge_name; +struct fields; +struct if_not_exists; +struct comment; +struct space_id; +struct index_name; +struct if_exists; +struct space_id; +struct index_name; +struct code; +struct leader; +struct item; +struct space_id; +struct code; +struct leader; +struct items; +struct space_id; +struct index_name; +struct account; +struct encoded_pwd; +struct if_not_exists; +struct account; +struct if_exists; +struct account; +struct encoded_pwd; +struct role_item; +struct role_item; +struct code; +struct leader; +struct users; +struct space_id; +struct code; +struct leader; +struct roles; +struct account; +struct account; +struct new_encoded_pwd; +struct old_encoded_pwd; +struct space_id; +struct id; +struct host_del; +struct stop; +struct reset; +struct id; +struct result; +struct code; +struct id; +struct leader; +struct tasks; +struct module; +struct name; +struct mode; +struct value; +struct items; +struct item; +struct code; +struct leader; +struct items; +struct item; +struct space; +struct module; +struct code; +struct leader; +struct items; +struct name; +struct name; +struct status; +struct hosts; +struct code; +struct leader; +struct snapshots; +struct space_id; +struct name; +struct status; +struct code; +struct leader; +struct statuses; +struct zone_name; +struct nodes; +struct zone_name; +struct node; +struct zone_name; +struct node; +struct zone_name; +struct zone_name; +struct code; +struct leader; +struct hosts; +struct zone_name; +struct nodes; +struct code; +struct leader; +struct zones; +struct group_name; +struct zone_names; +struct group_name; +struct zone_name; +struct group_name; +struct zone_name; +struct group_name; +struct group_name; +struct code; +struct leader; +struct zone_names; +struct group_name; +struct zone_names; +struct code; +struct leader; +struct groups; +struct space_id; +struct type; +struct hosts; +struct space_id; +struct type; +struct space_id; +struct type; +struct host; +struct part_id; +struct status; +struct code; +struct leader; +struct listeners; +struct space_id; +struct code; +struct leader; +struct stats; +struct host; +struct info; +struct space; +struct info; +struct backup_info; +struct meta_files; +struct backup_name; +struct full; +struct include_system_space; +struct create_time; +struct spaces; +struct code; +struct leader; +struct meta; +struct from_host; +struct to_host; +struct files; +struct hosts; +struct host; +struct user; +struct pwd; +struct type; +struct clients; +struct code; +struct leader; +struct clients; +struct space_id; +struct depend_schema; +struct fields; +struct fulltext_index_name; +struct index; +struct space_id; +struct fulltext_index_name; +struct code; +struct leader; +struct indexes; +struct start_time; +struct status; +struct duration; +struct query; +struct graph_addr; +struct session_id; +struct create_time; +struct update_time; +struct user_name; +struct space_name; +struct graph_addr; +struct timezone; +struct client_ip; +struct configs; +struct queries; +struct user; +struct graph_addr; +struct client_ip; +struct code; +struct leader; +struct session; +struct sessions; +struct code; +struct leader; +struct killed_queries; +struct code; +struct leader; +struct sessions; +struct session_id; +struct code; +struct leader; +struct session; +struct session_id; +struct kill_queries; +struct code; +struct job_id; +struct task_id; +struct stats; +struct code; +struct leader; +struct meta_servers; +struct storage_servers; +struct code; +struct dir; +struct code; +struct leader; +struct error_msg; +struct version; +} // namespace tag +namespace detail { +#ifndef APACHE_THRIFT_ACCESSOR_space_id +#define APACHE_THRIFT_ACCESSOR_space_id +APACHE_THRIFT_DEFINE_ACCESSOR(space_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_tag_id +#define APACHE_THRIFT_ACCESSOR_tag_id +APACHE_THRIFT_DEFINE_ACCESSOR(tag_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_edge_type +#define APACHE_THRIFT_ACCESSOR_edge_type +APACHE_THRIFT_DEFINE_ACCESSOR(edge_type); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_index_id +#define APACHE_THRIFT_ACCESSOR_index_id +APACHE_THRIFT_DEFINE_ACCESSOR(index_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_cluster_id +#define APACHE_THRIFT_ACCESSOR_cluster_id +APACHE_THRIFT_DEFINE_ACCESSOR(cluster_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_type +#define APACHE_THRIFT_ACCESSOR_type +APACHE_THRIFT_DEFINE_ACCESSOR(type); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_type_length +#define APACHE_THRIFT_ACCESSOR_type_length +APACHE_THRIFT_DEFINE_ACCESSOR(type_length); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_geo_shape +#define APACHE_THRIFT_ACCESSOR_geo_shape +APACHE_THRIFT_DEFINE_ACCESSOR(geo_shape); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_name +#define APACHE_THRIFT_ACCESSOR_name +APACHE_THRIFT_DEFINE_ACCESSOR(name); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_type +#define APACHE_THRIFT_ACCESSOR_type +APACHE_THRIFT_DEFINE_ACCESSOR(type); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_default_value +#define APACHE_THRIFT_ACCESSOR_default_value +APACHE_THRIFT_DEFINE_ACCESSOR(default_value); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_nullable +#define APACHE_THRIFT_ACCESSOR_nullable +APACHE_THRIFT_DEFINE_ACCESSOR(nullable); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_comment +#define APACHE_THRIFT_ACCESSOR_comment +APACHE_THRIFT_DEFINE_ACCESSOR(comment); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_ttl_duration +#define APACHE_THRIFT_ACCESSOR_ttl_duration +APACHE_THRIFT_DEFINE_ACCESSOR(ttl_duration); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_ttl_col +#define APACHE_THRIFT_ACCESSOR_ttl_col +APACHE_THRIFT_DEFINE_ACCESSOR(ttl_col); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_comment +#define APACHE_THRIFT_ACCESSOR_comment +APACHE_THRIFT_DEFINE_ACCESSOR(comment); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_columns +#define APACHE_THRIFT_ACCESSOR_columns +APACHE_THRIFT_DEFINE_ACCESSOR(columns); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_schema_prop +#define APACHE_THRIFT_ACCESSOR_schema_prop +APACHE_THRIFT_DEFINE_ACCESSOR(schema_prop); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_id +#define APACHE_THRIFT_ACCESSOR_id +APACHE_THRIFT_DEFINE_ACCESSOR(id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_name +#define APACHE_THRIFT_ACCESSOR_name +APACHE_THRIFT_DEFINE_ACCESSOR(name); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_space_name +#define APACHE_THRIFT_ACCESSOR_space_name +APACHE_THRIFT_DEFINE_ACCESSOR(space_name); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_partition_num +#define APACHE_THRIFT_ACCESSOR_partition_num +APACHE_THRIFT_DEFINE_ACCESSOR(partition_num); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_replica_factor +#define APACHE_THRIFT_ACCESSOR_replica_factor +APACHE_THRIFT_DEFINE_ACCESSOR(replica_factor); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_charset_name +#define APACHE_THRIFT_ACCESSOR_charset_name +APACHE_THRIFT_DEFINE_ACCESSOR(charset_name); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_collate_name +#define APACHE_THRIFT_ACCESSOR_collate_name +APACHE_THRIFT_DEFINE_ACCESSOR(collate_name); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_vid_type +#define APACHE_THRIFT_ACCESSOR_vid_type +APACHE_THRIFT_DEFINE_ACCESSOR(vid_type); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_group_name +#define APACHE_THRIFT_ACCESSOR_group_name +APACHE_THRIFT_DEFINE_ACCESSOR(group_name); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_isolation_level +#define APACHE_THRIFT_ACCESSOR_isolation_level +APACHE_THRIFT_DEFINE_ACCESSOR(isolation_level); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_comment +#define APACHE_THRIFT_ACCESSOR_comment +APACHE_THRIFT_DEFINE_ACCESSOR(comment); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_space_id +#define APACHE_THRIFT_ACCESSOR_space_id +APACHE_THRIFT_DEFINE_ACCESSOR(space_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_properties +#define APACHE_THRIFT_ACCESSOR_properties +APACHE_THRIFT_DEFINE_ACCESSOR(properties); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_tag_id +#define APACHE_THRIFT_ACCESSOR_tag_id +APACHE_THRIFT_DEFINE_ACCESSOR(tag_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_tag_name +#define APACHE_THRIFT_ACCESSOR_tag_name +APACHE_THRIFT_DEFINE_ACCESSOR(tag_name); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_version +#define APACHE_THRIFT_ACCESSOR_version +APACHE_THRIFT_DEFINE_ACCESSOR(version); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_schema +#define APACHE_THRIFT_ACCESSOR_schema +APACHE_THRIFT_DEFINE_ACCESSOR(schema); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_op +#define APACHE_THRIFT_ACCESSOR_op +APACHE_THRIFT_DEFINE_ACCESSOR(op); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_schema +#define APACHE_THRIFT_ACCESSOR_schema +APACHE_THRIFT_DEFINE_ACCESSOR(schema); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_edge_type +#define APACHE_THRIFT_ACCESSOR_edge_type +APACHE_THRIFT_DEFINE_ACCESSOR(edge_type); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_edge_name +#define APACHE_THRIFT_ACCESSOR_edge_name +APACHE_THRIFT_DEFINE_ACCESSOR(edge_name); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_version +#define APACHE_THRIFT_ACCESSOR_version +APACHE_THRIFT_DEFINE_ACCESSOR(version); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_schema +#define APACHE_THRIFT_ACCESSOR_schema +APACHE_THRIFT_DEFINE_ACCESSOR(schema); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_index_id +#define APACHE_THRIFT_ACCESSOR_index_id +APACHE_THRIFT_DEFINE_ACCESSOR(index_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_index_name +#define APACHE_THRIFT_ACCESSOR_index_name +APACHE_THRIFT_DEFINE_ACCESSOR(index_name); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_schema_id +#define APACHE_THRIFT_ACCESSOR_schema_id +APACHE_THRIFT_DEFINE_ACCESSOR(schema_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_schema_name +#define APACHE_THRIFT_ACCESSOR_schema_name +APACHE_THRIFT_DEFINE_ACCESSOR(schema_name); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_fields +#define APACHE_THRIFT_ACCESSOR_fields +APACHE_THRIFT_DEFINE_ACCESSOR(fields); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_comment +#define APACHE_THRIFT_ACCESSOR_comment +APACHE_THRIFT_DEFINE_ACCESSOR(comment); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_hostAddr +#define APACHE_THRIFT_ACCESSOR_hostAddr +APACHE_THRIFT_DEFINE_ACCESSOR(hostAddr); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_status +#define APACHE_THRIFT_ACCESSOR_status +APACHE_THRIFT_DEFINE_ACCESSOR(status); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_leader_parts +#define APACHE_THRIFT_ACCESSOR_leader_parts +APACHE_THRIFT_DEFINE_ACCESSOR(leader_parts); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_all_parts +#define APACHE_THRIFT_ACCESSOR_all_parts +APACHE_THRIFT_DEFINE_ACCESSOR(all_parts); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_role +#define APACHE_THRIFT_ACCESSOR_role +APACHE_THRIFT_DEFINE_ACCESSOR(role); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_git_info_sha +#define APACHE_THRIFT_ACCESSOR_git_info_sha +APACHE_THRIFT_DEFINE_ACCESSOR(git_info_sha); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_zone_name +#define APACHE_THRIFT_ACCESSOR_zone_name +APACHE_THRIFT_DEFINE_ACCESSOR(zone_name); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_version +#define APACHE_THRIFT_ACCESSOR_version +APACHE_THRIFT_DEFINE_ACCESSOR(version); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_account +#define APACHE_THRIFT_ACCESSOR_account +APACHE_THRIFT_DEFINE_ACCESSOR(account); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_is_lock +#define APACHE_THRIFT_ACCESSOR_is_lock +APACHE_THRIFT_DEFINE_ACCESSOR(is_lock); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_max_queries_per_hour +#define APACHE_THRIFT_ACCESSOR_max_queries_per_hour +APACHE_THRIFT_DEFINE_ACCESSOR(max_queries_per_hour); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_max_updates_per_hour +#define APACHE_THRIFT_ACCESSOR_max_updates_per_hour +APACHE_THRIFT_DEFINE_ACCESSOR(max_updates_per_hour); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_max_connections_per_hour +#define APACHE_THRIFT_ACCESSOR_max_connections_per_hour +APACHE_THRIFT_DEFINE_ACCESSOR(max_connections_per_hour); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_max_user_connections +#define APACHE_THRIFT_ACCESSOR_max_user_connections +APACHE_THRIFT_DEFINE_ACCESSOR(max_user_connections); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_user_id +#define APACHE_THRIFT_ACCESSOR_user_id +APACHE_THRIFT_DEFINE_ACCESSOR(user_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_space_id +#define APACHE_THRIFT_ACCESSOR_space_id +APACHE_THRIFT_DEFINE_ACCESSOR(space_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_role_type +#define APACHE_THRIFT_ACCESSOR_role_type +APACHE_THRIFT_DEFINE_ACCESSOR(role_type); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_code +#define APACHE_THRIFT_ACCESSOR_code +APACHE_THRIFT_DEFINE_ACCESSOR(code); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_id +#define APACHE_THRIFT_ACCESSOR_id +APACHE_THRIFT_DEFINE_ACCESSOR(id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_leader +#define APACHE_THRIFT_ACCESSOR_leader +APACHE_THRIFT_DEFINE_ACCESSOR(leader); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_op +#define APACHE_THRIFT_ACCESSOR_op +APACHE_THRIFT_DEFINE_ACCESSOR(op); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_cmd +#define APACHE_THRIFT_ACCESSOR_cmd +APACHE_THRIFT_DEFINE_ACCESSOR(cmd); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_paras +#define APACHE_THRIFT_ACCESSOR_paras +APACHE_THRIFT_DEFINE_ACCESSOR(paras); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_id +#define APACHE_THRIFT_ACCESSOR_id +APACHE_THRIFT_DEFINE_ACCESSOR(id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_cmd +#define APACHE_THRIFT_ACCESSOR_cmd +APACHE_THRIFT_DEFINE_ACCESSOR(cmd); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_paras +#define APACHE_THRIFT_ACCESSOR_paras +APACHE_THRIFT_DEFINE_ACCESSOR(paras); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_status +#define APACHE_THRIFT_ACCESSOR_status +APACHE_THRIFT_DEFINE_ACCESSOR(status); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_start_time +#define APACHE_THRIFT_ACCESSOR_start_time +APACHE_THRIFT_DEFINE_ACCESSOR(start_time); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_stop_time +#define APACHE_THRIFT_ACCESSOR_stop_time +APACHE_THRIFT_DEFINE_ACCESSOR(stop_time); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_task_id +#define APACHE_THRIFT_ACCESSOR_task_id +APACHE_THRIFT_DEFINE_ACCESSOR(task_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_host +#define APACHE_THRIFT_ACCESSOR_host +APACHE_THRIFT_DEFINE_ACCESSOR(host); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_status +#define APACHE_THRIFT_ACCESSOR_status +APACHE_THRIFT_DEFINE_ACCESSOR(status); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_start_time +#define APACHE_THRIFT_ACCESSOR_start_time +APACHE_THRIFT_DEFINE_ACCESSOR(start_time); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_stop_time +#define APACHE_THRIFT_ACCESSOR_stop_time +APACHE_THRIFT_DEFINE_ACCESSOR(stop_time); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_job_id +#define APACHE_THRIFT_ACCESSOR_job_id +APACHE_THRIFT_DEFINE_ACCESSOR(job_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_job_id +#define APACHE_THRIFT_ACCESSOR_job_id +APACHE_THRIFT_DEFINE_ACCESSOR(job_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_job_desc +#define APACHE_THRIFT_ACCESSOR_job_desc +APACHE_THRIFT_DEFINE_ACCESSOR(job_desc); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_task_desc +#define APACHE_THRIFT_ACCESSOR_task_desc +APACHE_THRIFT_DEFINE_ACCESSOR(task_desc); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_recovered_job_num +#define APACHE_THRIFT_ACCESSOR_recovered_job_num +APACHE_THRIFT_DEFINE_ACCESSOR(recovered_job_num); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_code +#define APACHE_THRIFT_ACCESSOR_code +APACHE_THRIFT_DEFINE_ACCESSOR(code); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_leader +#define APACHE_THRIFT_ACCESSOR_leader +APACHE_THRIFT_DEFINE_ACCESSOR(leader); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_result +#define APACHE_THRIFT_ACCESSOR_result +APACHE_THRIFT_DEFINE_ACCESSOR(result); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_part_id +#define APACHE_THRIFT_ACCESSOR_part_id +APACHE_THRIFT_DEFINE_ACCESSOR(part_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_proportion +#define APACHE_THRIFT_ACCESSOR_proportion +APACHE_THRIFT_DEFINE_ACCESSOR(proportion); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_tag_vertices +#define APACHE_THRIFT_ACCESSOR_tag_vertices +APACHE_THRIFT_DEFINE_ACCESSOR(tag_vertices); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_edges +#define APACHE_THRIFT_ACCESSOR_edges +APACHE_THRIFT_DEFINE_ACCESSOR(edges); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_space_vertices +#define APACHE_THRIFT_ACCESSOR_space_vertices +APACHE_THRIFT_DEFINE_ACCESSOR(space_vertices); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_space_edges +#define APACHE_THRIFT_ACCESSOR_space_edges +APACHE_THRIFT_DEFINE_ACCESSOR(space_edges); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_positive_part_correlativity +#define APACHE_THRIFT_ACCESSOR_positive_part_correlativity +APACHE_THRIFT_DEFINE_ACCESSOR(positive_part_correlativity); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_negative_part_correlativity +#define APACHE_THRIFT_ACCESSOR_negative_part_correlativity +APACHE_THRIFT_DEFINE_ACCESSOR(negative_part_correlativity); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_status +#define APACHE_THRIFT_ACCESSOR_status +APACHE_THRIFT_DEFINE_ACCESSOR(status); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_properties +#define APACHE_THRIFT_ACCESSOR_properties +APACHE_THRIFT_DEFINE_ACCESSOR(properties); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_if_not_exists +#define APACHE_THRIFT_ACCESSOR_if_not_exists +APACHE_THRIFT_DEFINE_ACCESSOR(if_not_exists); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_old_space_name +#define APACHE_THRIFT_ACCESSOR_old_space_name +APACHE_THRIFT_DEFINE_ACCESSOR(old_space_name); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_new_space_name +#define APACHE_THRIFT_ACCESSOR_new_space_name +APACHE_THRIFT_DEFINE_ACCESSOR(new_space_name); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_space_name +#define APACHE_THRIFT_ACCESSOR_space_name +APACHE_THRIFT_DEFINE_ACCESSOR(space_name); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_if_exists +#define APACHE_THRIFT_ACCESSOR_if_exists +APACHE_THRIFT_DEFINE_ACCESSOR(if_exists); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_code +#define APACHE_THRIFT_ACCESSOR_code +APACHE_THRIFT_DEFINE_ACCESSOR(code); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_leader +#define APACHE_THRIFT_ACCESSOR_leader +APACHE_THRIFT_DEFINE_ACCESSOR(leader); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_spaces +#define APACHE_THRIFT_ACCESSOR_spaces +APACHE_THRIFT_DEFINE_ACCESSOR(spaces); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_space_name +#define APACHE_THRIFT_ACCESSOR_space_name +APACHE_THRIFT_DEFINE_ACCESSOR(space_name); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_code +#define APACHE_THRIFT_ACCESSOR_code +APACHE_THRIFT_DEFINE_ACCESSOR(code); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_leader +#define APACHE_THRIFT_ACCESSOR_leader +APACHE_THRIFT_DEFINE_ACCESSOR(leader); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_item +#define APACHE_THRIFT_ACCESSOR_item +APACHE_THRIFT_DEFINE_ACCESSOR(item); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_space_id +#define APACHE_THRIFT_ACCESSOR_space_id +APACHE_THRIFT_DEFINE_ACCESSOR(space_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_tag_name +#define APACHE_THRIFT_ACCESSOR_tag_name +APACHE_THRIFT_DEFINE_ACCESSOR(tag_name); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_schema +#define APACHE_THRIFT_ACCESSOR_schema +APACHE_THRIFT_DEFINE_ACCESSOR(schema); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_if_not_exists +#define APACHE_THRIFT_ACCESSOR_if_not_exists +APACHE_THRIFT_DEFINE_ACCESSOR(if_not_exists); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_space_id +#define APACHE_THRIFT_ACCESSOR_space_id +APACHE_THRIFT_DEFINE_ACCESSOR(space_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_tag_name +#define APACHE_THRIFT_ACCESSOR_tag_name +APACHE_THRIFT_DEFINE_ACCESSOR(tag_name); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_tag_items +#define APACHE_THRIFT_ACCESSOR_tag_items +APACHE_THRIFT_DEFINE_ACCESSOR(tag_items); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_schema_prop +#define APACHE_THRIFT_ACCESSOR_schema_prop +APACHE_THRIFT_DEFINE_ACCESSOR(schema_prop); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_space_id +#define APACHE_THRIFT_ACCESSOR_space_id +APACHE_THRIFT_DEFINE_ACCESSOR(space_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_tag_name +#define APACHE_THRIFT_ACCESSOR_tag_name +APACHE_THRIFT_DEFINE_ACCESSOR(tag_name); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_if_exists +#define APACHE_THRIFT_ACCESSOR_if_exists +APACHE_THRIFT_DEFINE_ACCESSOR(if_exists); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_space_id +#define APACHE_THRIFT_ACCESSOR_space_id +APACHE_THRIFT_DEFINE_ACCESSOR(space_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_code +#define APACHE_THRIFT_ACCESSOR_code +APACHE_THRIFT_DEFINE_ACCESSOR(code); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_leader +#define APACHE_THRIFT_ACCESSOR_leader +APACHE_THRIFT_DEFINE_ACCESSOR(leader); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_tags +#define APACHE_THRIFT_ACCESSOR_tags +APACHE_THRIFT_DEFINE_ACCESSOR(tags); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_space_id +#define APACHE_THRIFT_ACCESSOR_space_id +APACHE_THRIFT_DEFINE_ACCESSOR(space_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_tag_name +#define APACHE_THRIFT_ACCESSOR_tag_name +APACHE_THRIFT_DEFINE_ACCESSOR(tag_name); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_version +#define APACHE_THRIFT_ACCESSOR_version +APACHE_THRIFT_DEFINE_ACCESSOR(version); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_code +#define APACHE_THRIFT_ACCESSOR_code +APACHE_THRIFT_DEFINE_ACCESSOR(code); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_leader +#define APACHE_THRIFT_ACCESSOR_leader +APACHE_THRIFT_DEFINE_ACCESSOR(leader); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_schema +#define APACHE_THRIFT_ACCESSOR_schema +APACHE_THRIFT_DEFINE_ACCESSOR(schema); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_space_id +#define APACHE_THRIFT_ACCESSOR_space_id +APACHE_THRIFT_DEFINE_ACCESSOR(space_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_edge_name +#define APACHE_THRIFT_ACCESSOR_edge_name +APACHE_THRIFT_DEFINE_ACCESSOR(edge_name); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_schema +#define APACHE_THRIFT_ACCESSOR_schema +APACHE_THRIFT_DEFINE_ACCESSOR(schema); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_if_not_exists +#define APACHE_THRIFT_ACCESSOR_if_not_exists +APACHE_THRIFT_DEFINE_ACCESSOR(if_not_exists); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_space_id +#define APACHE_THRIFT_ACCESSOR_space_id +APACHE_THRIFT_DEFINE_ACCESSOR(space_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_edge_name +#define APACHE_THRIFT_ACCESSOR_edge_name +APACHE_THRIFT_DEFINE_ACCESSOR(edge_name); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_edge_items +#define APACHE_THRIFT_ACCESSOR_edge_items +APACHE_THRIFT_DEFINE_ACCESSOR(edge_items); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_schema_prop +#define APACHE_THRIFT_ACCESSOR_schema_prop +APACHE_THRIFT_DEFINE_ACCESSOR(schema_prop); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_space_id +#define APACHE_THRIFT_ACCESSOR_space_id +APACHE_THRIFT_DEFINE_ACCESSOR(space_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_edge_name +#define APACHE_THRIFT_ACCESSOR_edge_name +APACHE_THRIFT_DEFINE_ACCESSOR(edge_name); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_version +#define APACHE_THRIFT_ACCESSOR_version +APACHE_THRIFT_DEFINE_ACCESSOR(version); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_code +#define APACHE_THRIFT_ACCESSOR_code +APACHE_THRIFT_DEFINE_ACCESSOR(code); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_leader +#define APACHE_THRIFT_ACCESSOR_leader +APACHE_THRIFT_DEFINE_ACCESSOR(leader); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_schema +#define APACHE_THRIFT_ACCESSOR_schema +APACHE_THRIFT_DEFINE_ACCESSOR(schema); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_space_id +#define APACHE_THRIFT_ACCESSOR_space_id +APACHE_THRIFT_DEFINE_ACCESSOR(space_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_edge_name +#define APACHE_THRIFT_ACCESSOR_edge_name +APACHE_THRIFT_DEFINE_ACCESSOR(edge_name); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_if_exists +#define APACHE_THRIFT_ACCESSOR_if_exists +APACHE_THRIFT_DEFINE_ACCESSOR(if_exists); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_space_id +#define APACHE_THRIFT_ACCESSOR_space_id +APACHE_THRIFT_DEFINE_ACCESSOR(space_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_code +#define APACHE_THRIFT_ACCESSOR_code +APACHE_THRIFT_DEFINE_ACCESSOR(code); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_leader +#define APACHE_THRIFT_ACCESSOR_leader +APACHE_THRIFT_DEFINE_ACCESSOR(leader); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_edges +#define APACHE_THRIFT_ACCESSOR_edges +APACHE_THRIFT_DEFINE_ACCESSOR(edges); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_type +#define APACHE_THRIFT_ACCESSOR_type +APACHE_THRIFT_DEFINE_ACCESSOR(type); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_code +#define APACHE_THRIFT_ACCESSOR_code +APACHE_THRIFT_DEFINE_ACCESSOR(code); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_leader +#define APACHE_THRIFT_ACCESSOR_leader +APACHE_THRIFT_DEFINE_ACCESSOR(leader); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_hosts +#define APACHE_THRIFT_ACCESSOR_hosts +APACHE_THRIFT_DEFINE_ACCESSOR(hosts); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_part_id +#define APACHE_THRIFT_ACCESSOR_part_id +APACHE_THRIFT_DEFINE_ACCESSOR(part_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_leader +#define APACHE_THRIFT_ACCESSOR_leader +APACHE_THRIFT_DEFINE_ACCESSOR(leader); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_peers +#define APACHE_THRIFT_ACCESSOR_peers +APACHE_THRIFT_DEFINE_ACCESSOR(peers); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_losts +#define APACHE_THRIFT_ACCESSOR_losts +APACHE_THRIFT_DEFINE_ACCESSOR(losts); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_space_id +#define APACHE_THRIFT_ACCESSOR_space_id +APACHE_THRIFT_DEFINE_ACCESSOR(space_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_part_ids +#define APACHE_THRIFT_ACCESSOR_part_ids +APACHE_THRIFT_DEFINE_ACCESSOR(part_ids); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_code +#define APACHE_THRIFT_ACCESSOR_code +APACHE_THRIFT_DEFINE_ACCESSOR(code); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_leader +#define APACHE_THRIFT_ACCESSOR_leader +APACHE_THRIFT_DEFINE_ACCESSOR(leader); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_parts +#define APACHE_THRIFT_ACCESSOR_parts +APACHE_THRIFT_DEFINE_ACCESSOR(parts); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_space_id +#define APACHE_THRIFT_ACCESSOR_space_id +APACHE_THRIFT_DEFINE_ACCESSOR(space_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_code +#define APACHE_THRIFT_ACCESSOR_code +APACHE_THRIFT_DEFINE_ACCESSOR(code); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_leader +#define APACHE_THRIFT_ACCESSOR_leader +APACHE_THRIFT_DEFINE_ACCESSOR(leader); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_parts +#define APACHE_THRIFT_ACCESSOR_parts +APACHE_THRIFT_DEFINE_ACCESSOR(parts); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_terms +#define APACHE_THRIFT_ACCESSOR_terms +APACHE_THRIFT_DEFINE_ACCESSOR(terms); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_segment +#define APACHE_THRIFT_ACCESSOR_segment +APACHE_THRIFT_DEFINE_ACCESSOR(segment); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_pairs +#define APACHE_THRIFT_ACCESSOR_pairs +APACHE_THRIFT_DEFINE_ACCESSOR(pairs); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_segment +#define APACHE_THRIFT_ACCESSOR_segment +APACHE_THRIFT_DEFINE_ACCESSOR(segment); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_key +#define APACHE_THRIFT_ACCESSOR_key +APACHE_THRIFT_DEFINE_ACCESSOR(key); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_code +#define APACHE_THRIFT_ACCESSOR_code +APACHE_THRIFT_DEFINE_ACCESSOR(code); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_leader +#define APACHE_THRIFT_ACCESSOR_leader +APACHE_THRIFT_DEFINE_ACCESSOR(leader); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_value +#define APACHE_THRIFT_ACCESSOR_value +APACHE_THRIFT_DEFINE_ACCESSOR(value); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_segment +#define APACHE_THRIFT_ACCESSOR_segment +APACHE_THRIFT_DEFINE_ACCESSOR(segment); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_keys +#define APACHE_THRIFT_ACCESSOR_keys +APACHE_THRIFT_DEFINE_ACCESSOR(keys); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_code +#define APACHE_THRIFT_ACCESSOR_code +APACHE_THRIFT_DEFINE_ACCESSOR(code); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_leader +#define APACHE_THRIFT_ACCESSOR_leader +APACHE_THRIFT_DEFINE_ACCESSOR(leader); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_values +#define APACHE_THRIFT_ACCESSOR_values +APACHE_THRIFT_DEFINE_ACCESSOR(values); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_segment +#define APACHE_THRIFT_ACCESSOR_segment +APACHE_THRIFT_DEFINE_ACCESSOR(segment); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_key +#define APACHE_THRIFT_ACCESSOR_key +APACHE_THRIFT_DEFINE_ACCESSOR(key); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_segment +#define APACHE_THRIFT_ACCESSOR_segment +APACHE_THRIFT_DEFINE_ACCESSOR(segment); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_start +#define APACHE_THRIFT_ACCESSOR_start +APACHE_THRIFT_DEFINE_ACCESSOR(start); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_end +#define APACHE_THRIFT_ACCESSOR_end +APACHE_THRIFT_DEFINE_ACCESSOR(end); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_segment +#define APACHE_THRIFT_ACCESSOR_segment +APACHE_THRIFT_DEFINE_ACCESSOR(segment); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_start +#define APACHE_THRIFT_ACCESSOR_start +APACHE_THRIFT_DEFINE_ACCESSOR(start); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_end +#define APACHE_THRIFT_ACCESSOR_end +APACHE_THRIFT_DEFINE_ACCESSOR(end); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_code +#define APACHE_THRIFT_ACCESSOR_code +APACHE_THRIFT_DEFINE_ACCESSOR(code); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_leader +#define APACHE_THRIFT_ACCESSOR_leader +APACHE_THRIFT_DEFINE_ACCESSOR(leader); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_values +#define APACHE_THRIFT_ACCESSOR_values +APACHE_THRIFT_DEFINE_ACCESSOR(values); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_code +#define APACHE_THRIFT_ACCESSOR_code +APACHE_THRIFT_DEFINE_ACCESSOR(code); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_leader +#define APACHE_THRIFT_ACCESSOR_leader +APACHE_THRIFT_DEFINE_ACCESSOR(leader); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_cluster_id +#define APACHE_THRIFT_ACCESSOR_cluster_id +APACHE_THRIFT_DEFINE_ACCESSOR(cluster_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_last_update_time_in_ms +#define APACHE_THRIFT_ACCESSOR_last_update_time_in_ms +APACHE_THRIFT_DEFINE_ACCESSOR(last_update_time_in_ms); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_meta_version +#define APACHE_THRIFT_ACCESSOR_meta_version +APACHE_THRIFT_DEFINE_ACCESSOR(meta_version); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_part_id +#define APACHE_THRIFT_ACCESSOR_part_id +APACHE_THRIFT_DEFINE_ACCESSOR(part_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_term +#define APACHE_THRIFT_ACCESSOR_term +APACHE_THRIFT_DEFINE_ACCESSOR(term); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_role +#define APACHE_THRIFT_ACCESSOR_role +APACHE_THRIFT_DEFINE_ACCESSOR(role); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_host +#define APACHE_THRIFT_ACCESSOR_host +APACHE_THRIFT_DEFINE_ACCESSOR(host); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_cluster_id +#define APACHE_THRIFT_ACCESSOR_cluster_id +APACHE_THRIFT_DEFINE_ACCESSOR(cluster_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_leader_partIds +#define APACHE_THRIFT_ACCESSOR_leader_partIds +APACHE_THRIFT_DEFINE_ACCESSOR(leader_partIds); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_git_info_sha +#define APACHE_THRIFT_ACCESSOR_git_info_sha +APACHE_THRIFT_DEFINE_ACCESSOR(git_info_sha); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_version +#define APACHE_THRIFT_ACCESSOR_version +APACHE_THRIFT_DEFINE_ACCESSOR(version); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_name +#define APACHE_THRIFT_ACCESSOR_name +APACHE_THRIFT_DEFINE_ACCESSOR(name); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_type_length +#define APACHE_THRIFT_ACCESSOR_type_length +APACHE_THRIFT_DEFINE_ACCESSOR(type_length); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_space_id +#define APACHE_THRIFT_ACCESSOR_space_id +APACHE_THRIFT_DEFINE_ACCESSOR(space_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_index_name +#define APACHE_THRIFT_ACCESSOR_index_name +APACHE_THRIFT_DEFINE_ACCESSOR(index_name); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_tag_name +#define APACHE_THRIFT_ACCESSOR_tag_name +APACHE_THRIFT_DEFINE_ACCESSOR(tag_name); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_fields +#define APACHE_THRIFT_ACCESSOR_fields +APACHE_THRIFT_DEFINE_ACCESSOR(fields); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_if_not_exists +#define APACHE_THRIFT_ACCESSOR_if_not_exists +APACHE_THRIFT_DEFINE_ACCESSOR(if_not_exists); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_comment +#define APACHE_THRIFT_ACCESSOR_comment +APACHE_THRIFT_DEFINE_ACCESSOR(comment); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_space_id +#define APACHE_THRIFT_ACCESSOR_space_id +APACHE_THRIFT_DEFINE_ACCESSOR(space_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_index_name +#define APACHE_THRIFT_ACCESSOR_index_name +APACHE_THRIFT_DEFINE_ACCESSOR(index_name); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_if_exists +#define APACHE_THRIFT_ACCESSOR_if_exists +APACHE_THRIFT_DEFINE_ACCESSOR(if_exists); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_space_id +#define APACHE_THRIFT_ACCESSOR_space_id +APACHE_THRIFT_DEFINE_ACCESSOR(space_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_index_name +#define APACHE_THRIFT_ACCESSOR_index_name +APACHE_THRIFT_DEFINE_ACCESSOR(index_name); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_code +#define APACHE_THRIFT_ACCESSOR_code +APACHE_THRIFT_DEFINE_ACCESSOR(code); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_leader +#define APACHE_THRIFT_ACCESSOR_leader +APACHE_THRIFT_DEFINE_ACCESSOR(leader); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_item +#define APACHE_THRIFT_ACCESSOR_item +APACHE_THRIFT_DEFINE_ACCESSOR(item); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_space_id +#define APACHE_THRIFT_ACCESSOR_space_id +APACHE_THRIFT_DEFINE_ACCESSOR(space_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_code +#define APACHE_THRIFT_ACCESSOR_code +APACHE_THRIFT_DEFINE_ACCESSOR(code); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_leader +#define APACHE_THRIFT_ACCESSOR_leader +APACHE_THRIFT_DEFINE_ACCESSOR(leader); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_items +#define APACHE_THRIFT_ACCESSOR_items +APACHE_THRIFT_DEFINE_ACCESSOR(items); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_space_id +#define APACHE_THRIFT_ACCESSOR_space_id +APACHE_THRIFT_DEFINE_ACCESSOR(space_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_index_name +#define APACHE_THRIFT_ACCESSOR_index_name +APACHE_THRIFT_DEFINE_ACCESSOR(index_name); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_edge_name +#define APACHE_THRIFT_ACCESSOR_edge_name +APACHE_THRIFT_DEFINE_ACCESSOR(edge_name); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_fields +#define APACHE_THRIFT_ACCESSOR_fields +APACHE_THRIFT_DEFINE_ACCESSOR(fields); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_if_not_exists +#define APACHE_THRIFT_ACCESSOR_if_not_exists +APACHE_THRIFT_DEFINE_ACCESSOR(if_not_exists); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_comment +#define APACHE_THRIFT_ACCESSOR_comment +APACHE_THRIFT_DEFINE_ACCESSOR(comment); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_space_id +#define APACHE_THRIFT_ACCESSOR_space_id +APACHE_THRIFT_DEFINE_ACCESSOR(space_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_index_name +#define APACHE_THRIFT_ACCESSOR_index_name +APACHE_THRIFT_DEFINE_ACCESSOR(index_name); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_if_exists +#define APACHE_THRIFT_ACCESSOR_if_exists +APACHE_THRIFT_DEFINE_ACCESSOR(if_exists); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_space_id +#define APACHE_THRIFT_ACCESSOR_space_id +APACHE_THRIFT_DEFINE_ACCESSOR(space_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_index_name +#define APACHE_THRIFT_ACCESSOR_index_name +APACHE_THRIFT_DEFINE_ACCESSOR(index_name); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_code +#define APACHE_THRIFT_ACCESSOR_code +APACHE_THRIFT_DEFINE_ACCESSOR(code); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_leader +#define APACHE_THRIFT_ACCESSOR_leader +APACHE_THRIFT_DEFINE_ACCESSOR(leader); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_item +#define APACHE_THRIFT_ACCESSOR_item +APACHE_THRIFT_DEFINE_ACCESSOR(item); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_space_id +#define APACHE_THRIFT_ACCESSOR_space_id +APACHE_THRIFT_DEFINE_ACCESSOR(space_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_code +#define APACHE_THRIFT_ACCESSOR_code +APACHE_THRIFT_DEFINE_ACCESSOR(code); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_leader +#define APACHE_THRIFT_ACCESSOR_leader +APACHE_THRIFT_DEFINE_ACCESSOR(leader); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_items +#define APACHE_THRIFT_ACCESSOR_items +APACHE_THRIFT_DEFINE_ACCESSOR(items); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_space_id +#define APACHE_THRIFT_ACCESSOR_space_id +APACHE_THRIFT_DEFINE_ACCESSOR(space_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_index_name +#define APACHE_THRIFT_ACCESSOR_index_name +APACHE_THRIFT_DEFINE_ACCESSOR(index_name); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_account +#define APACHE_THRIFT_ACCESSOR_account +APACHE_THRIFT_DEFINE_ACCESSOR(account); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_encoded_pwd +#define APACHE_THRIFT_ACCESSOR_encoded_pwd +APACHE_THRIFT_DEFINE_ACCESSOR(encoded_pwd); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_if_not_exists +#define APACHE_THRIFT_ACCESSOR_if_not_exists +APACHE_THRIFT_DEFINE_ACCESSOR(if_not_exists); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_account +#define APACHE_THRIFT_ACCESSOR_account +APACHE_THRIFT_DEFINE_ACCESSOR(account); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_if_exists +#define APACHE_THRIFT_ACCESSOR_if_exists +APACHE_THRIFT_DEFINE_ACCESSOR(if_exists); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_account +#define APACHE_THRIFT_ACCESSOR_account +APACHE_THRIFT_DEFINE_ACCESSOR(account); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_encoded_pwd +#define APACHE_THRIFT_ACCESSOR_encoded_pwd +APACHE_THRIFT_DEFINE_ACCESSOR(encoded_pwd); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_role_item +#define APACHE_THRIFT_ACCESSOR_role_item +APACHE_THRIFT_DEFINE_ACCESSOR(role_item); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_role_item +#define APACHE_THRIFT_ACCESSOR_role_item +APACHE_THRIFT_DEFINE_ACCESSOR(role_item); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_code +#define APACHE_THRIFT_ACCESSOR_code +APACHE_THRIFT_DEFINE_ACCESSOR(code); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_leader +#define APACHE_THRIFT_ACCESSOR_leader +APACHE_THRIFT_DEFINE_ACCESSOR(leader); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_users +#define APACHE_THRIFT_ACCESSOR_users +APACHE_THRIFT_DEFINE_ACCESSOR(users); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_space_id +#define APACHE_THRIFT_ACCESSOR_space_id +APACHE_THRIFT_DEFINE_ACCESSOR(space_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_code +#define APACHE_THRIFT_ACCESSOR_code +APACHE_THRIFT_DEFINE_ACCESSOR(code); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_leader +#define APACHE_THRIFT_ACCESSOR_leader +APACHE_THRIFT_DEFINE_ACCESSOR(leader); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_roles +#define APACHE_THRIFT_ACCESSOR_roles +APACHE_THRIFT_DEFINE_ACCESSOR(roles); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_account +#define APACHE_THRIFT_ACCESSOR_account +APACHE_THRIFT_DEFINE_ACCESSOR(account); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_account +#define APACHE_THRIFT_ACCESSOR_account +APACHE_THRIFT_DEFINE_ACCESSOR(account); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_new_encoded_pwd +#define APACHE_THRIFT_ACCESSOR_new_encoded_pwd +APACHE_THRIFT_DEFINE_ACCESSOR(new_encoded_pwd); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_old_encoded_pwd +#define APACHE_THRIFT_ACCESSOR_old_encoded_pwd +APACHE_THRIFT_DEFINE_ACCESSOR(old_encoded_pwd); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_space_id +#define APACHE_THRIFT_ACCESSOR_space_id +APACHE_THRIFT_DEFINE_ACCESSOR(space_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_id +#define APACHE_THRIFT_ACCESSOR_id +APACHE_THRIFT_DEFINE_ACCESSOR(id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_host_del +#define APACHE_THRIFT_ACCESSOR_host_del +APACHE_THRIFT_DEFINE_ACCESSOR(host_del); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_stop +#define APACHE_THRIFT_ACCESSOR_stop +APACHE_THRIFT_DEFINE_ACCESSOR(stop); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_reset +#define APACHE_THRIFT_ACCESSOR_reset +APACHE_THRIFT_DEFINE_ACCESSOR(reset); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_id +#define APACHE_THRIFT_ACCESSOR_id +APACHE_THRIFT_DEFINE_ACCESSOR(id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_result +#define APACHE_THRIFT_ACCESSOR_result +APACHE_THRIFT_DEFINE_ACCESSOR(result); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_code +#define APACHE_THRIFT_ACCESSOR_code +APACHE_THRIFT_DEFINE_ACCESSOR(code); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_id +#define APACHE_THRIFT_ACCESSOR_id +APACHE_THRIFT_DEFINE_ACCESSOR(id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_leader +#define APACHE_THRIFT_ACCESSOR_leader +APACHE_THRIFT_DEFINE_ACCESSOR(leader); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_tasks +#define APACHE_THRIFT_ACCESSOR_tasks +APACHE_THRIFT_DEFINE_ACCESSOR(tasks); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_module +#define APACHE_THRIFT_ACCESSOR_module +APACHE_THRIFT_DEFINE_ACCESSOR(module); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_name +#define APACHE_THRIFT_ACCESSOR_name +APACHE_THRIFT_DEFINE_ACCESSOR(name); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_mode +#define APACHE_THRIFT_ACCESSOR_mode +APACHE_THRIFT_DEFINE_ACCESSOR(mode); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_value +#define APACHE_THRIFT_ACCESSOR_value +APACHE_THRIFT_DEFINE_ACCESSOR(value); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_items +#define APACHE_THRIFT_ACCESSOR_items +APACHE_THRIFT_DEFINE_ACCESSOR(items); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_item +#define APACHE_THRIFT_ACCESSOR_item +APACHE_THRIFT_DEFINE_ACCESSOR(item); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_code +#define APACHE_THRIFT_ACCESSOR_code +APACHE_THRIFT_DEFINE_ACCESSOR(code); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_leader +#define APACHE_THRIFT_ACCESSOR_leader +APACHE_THRIFT_DEFINE_ACCESSOR(leader); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_items +#define APACHE_THRIFT_ACCESSOR_items +APACHE_THRIFT_DEFINE_ACCESSOR(items); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_item +#define APACHE_THRIFT_ACCESSOR_item +APACHE_THRIFT_DEFINE_ACCESSOR(item); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_space +#define APACHE_THRIFT_ACCESSOR_space +APACHE_THRIFT_DEFINE_ACCESSOR(space); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_module +#define APACHE_THRIFT_ACCESSOR_module +APACHE_THRIFT_DEFINE_ACCESSOR(module); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_code +#define APACHE_THRIFT_ACCESSOR_code +APACHE_THRIFT_DEFINE_ACCESSOR(code); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_leader +#define APACHE_THRIFT_ACCESSOR_leader +APACHE_THRIFT_DEFINE_ACCESSOR(leader); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_items +#define APACHE_THRIFT_ACCESSOR_items +APACHE_THRIFT_DEFINE_ACCESSOR(items); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_name +#define APACHE_THRIFT_ACCESSOR_name +APACHE_THRIFT_DEFINE_ACCESSOR(name); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_name +#define APACHE_THRIFT_ACCESSOR_name +APACHE_THRIFT_DEFINE_ACCESSOR(name); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_status +#define APACHE_THRIFT_ACCESSOR_status +APACHE_THRIFT_DEFINE_ACCESSOR(status); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_hosts +#define APACHE_THRIFT_ACCESSOR_hosts +APACHE_THRIFT_DEFINE_ACCESSOR(hosts); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_code +#define APACHE_THRIFT_ACCESSOR_code +APACHE_THRIFT_DEFINE_ACCESSOR(code); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_leader +#define APACHE_THRIFT_ACCESSOR_leader +APACHE_THRIFT_DEFINE_ACCESSOR(leader); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_snapshots +#define APACHE_THRIFT_ACCESSOR_snapshots +APACHE_THRIFT_DEFINE_ACCESSOR(snapshots); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_space_id +#define APACHE_THRIFT_ACCESSOR_space_id +APACHE_THRIFT_DEFINE_ACCESSOR(space_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_name +#define APACHE_THRIFT_ACCESSOR_name +APACHE_THRIFT_DEFINE_ACCESSOR(name); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_status +#define APACHE_THRIFT_ACCESSOR_status +APACHE_THRIFT_DEFINE_ACCESSOR(status); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_code +#define APACHE_THRIFT_ACCESSOR_code +APACHE_THRIFT_DEFINE_ACCESSOR(code); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_leader +#define APACHE_THRIFT_ACCESSOR_leader +APACHE_THRIFT_DEFINE_ACCESSOR(leader); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_statuses +#define APACHE_THRIFT_ACCESSOR_statuses +APACHE_THRIFT_DEFINE_ACCESSOR(statuses); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_zone_name +#define APACHE_THRIFT_ACCESSOR_zone_name +APACHE_THRIFT_DEFINE_ACCESSOR(zone_name); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_nodes +#define APACHE_THRIFT_ACCESSOR_nodes +APACHE_THRIFT_DEFINE_ACCESSOR(nodes); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_zone_name +#define APACHE_THRIFT_ACCESSOR_zone_name +APACHE_THRIFT_DEFINE_ACCESSOR(zone_name); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_node +#define APACHE_THRIFT_ACCESSOR_node +APACHE_THRIFT_DEFINE_ACCESSOR(node); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_zone_name +#define APACHE_THRIFT_ACCESSOR_zone_name +APACHE_THRIFT_DEFINE_ACCESSOR(zone_name); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_node +#define APACHE_THRIFT_ACCESSOR_node +APACHE_THRIFT_DEFINE_ACCESSOR(node); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_zone_name +#define APACHE_THRIFT_ACCESSOR_zone_name +APACHE_THRIFT_DEFINE_ACCESSOR(zone_name); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_zone_name +#define APACHE_THRIFT_ACCESSOR_zone_name +APACHE_THRIFT_DEFINE_ACCESSOR(zone_name); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_code +#define APACHE_THRIFT_ACCESSOR_code +APACHE_THRIFT_DEFINE_ACCESSOR(code); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_leader +#define APACHE_THRIFT_ACCESSOR_leader +APACHE_THRIFT_DEFINE_ACCESSOR(leader); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_hosts +#define APACHE_THRIFT_ACCESSOR_hosts +APACHE_THRIFT_DEFINE_ACCESSOR(hosts); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_zone_name +#define APACHE_THRIFT_ACCESSOR_zone_name +APACHE_THRIFT_DEFINE_ACCESSOR(zone_name); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_nodes +#define APACHE_THRIFT_ACCESSOR_nodes +APACHE_THRIFT_DEFINE_ACCESSOR(nodes); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_code +#define APACHE_THRIFT_ACCESSOR_code +APACHE_THRIFT_DEFINE_ACCESSOR(code); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_leader +#define APACHE_THRIFT_ACCESSOR_leader +APACHE_THRIFT_DEFINE_ACCESSOR(leader); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_zones +#define APACHE_THRIFT_ACCESSOR_zones +APACHE_THRIFT_DEFINE_ACCESSOR(zones); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_group_name +#define APACHE_THRIFT_ACCESSOR_group_name +APACHE_THRIFT_DEFINE_ACCESSOR(group_name); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_zone_names +#define APACHE_THRIFT_ACCESSOR_zone_names +APACHE_THRIFT_DEFINE_ACCESSOR(zone_names); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_group_name +#define APACHE_THRIFT_ACCESSOR_group_name +APACHE_THRIFT_DEFINE_ACCESSOR(group_name); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_zone_name +#define APACHE_THRIFT_ACCESSOR_zone_name +APACHE_THRIFT_DEFINE_ACCESSOR(zone_name); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_group_name +#define APACHE_THRIFT_ACCESSOR_group_name +APACHE_THRIFT_DEFINE_ACCESSOR(group_name); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_zone_name +#define APACHE_THRIFT_ACCESSOR_zone_name +APACHE_THRIFT_DEFINE_ACCESSOR(zone_name); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_group_name +#define APACHE_THRIFT_ACCESSOR_group_name +APACHE_THRIFT_DEFINE_ACCESSOR(group_name); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_group_name +#define APACHE_THRIFT_ACCESSOR_group_name +APACHE_THRIFT_DEFINE_ACCESSOR(group_name); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_code +#define APACHE_THRIFT_ACCESSOR_code +APACHE_THRIFT_DEFINE_ACCESSOR(code); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_leader +#define APACHE_THRIFT_ACCESSOR_leader +APACHE_THRIFT_DEFINE_ACCESSOR(leader); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_zone_names +#define APACHE_THRIFT_ACCESSOR_zone_names +APACHE_THRIFT_DEFINE_ACCESSOR(zone_names); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_group_name +#define APACHE_THRIFT_ACCESSOR_group_name +APACHE_THRIFT_DEFINE_ACCESSOR(group_name); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_zone_names +#define APACHE_THRIFT_ACCESSOR_zone_names +APACHE_THRIFT_DEFINE_ACCESSOR(zone_names); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_code +#define APACHE_THRIFT_ACCESSOR_code +APACHE_THRIFT_DEFINE_ACCESSOR(code); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_leader +#define APACHE_THRIFT_ACCESSOR_leader +APACHE_THRIFT_DEFINE_ACCESSOR(leader); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_groups +#define APACHE_THRIFT_ACCESSOR_groups +APACHE_THRIFT_DEFINE_ACCESSOR(groups); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_space_id +#define APACHE_THRIFT_ACCESSOR_space_id +APACHE_THRIFT_DEFINE_ACCESSOR(space_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_type +#define APACHE_THRIFT_ACCESSOR_type +APACHE_THRIFT_DEFINE_ACCESSOR(type); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_hosts +#define APACHE_THRIFT_ACCESSOR_hosts +APACHE_THRIFT_DEFINE_ACCESSOR(hosts); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_space_id +#define APACHE_THRIFT_ACCESSOR_space_id +APACHE_THRIFT_DEFINE_ACCESSOR(space_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_type +#define APACHE_THRIFT_ACCESSOR_type +APACHE_THRIFT_DEFINE_ACCESSOR(type); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_space_id +#define APACHE_THRIFT_ACCESSOR_space_id +APACHE_THRIFT_DEFINE_ACCESSOR(space_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_type +#define APACHE_THRIFT_ACCESSOR_type +APACHE_THRIFT_DEFINE_ACCESSOR(type); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_host +#define APACHE_THRIFT_ACCESSOR_host +APACHE_THRIFT_DEFINE_ACCESSOR(host); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_part_id +#define APACHE_THRIFT_ACCESSOR_part_id +APACHE_THRIFT_DEFINE_ACCESSOR(part_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_status +#define APACHE_THRIFT_ACCESSOR_status +APACHE_THRIFT_DEFINE_ACCESSOR(status); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_code +#define APACHE_THRIFT_ACCESSOR_code +APACHE_THRIFT_DEFINE_ACCESSOR(code); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_leader +#define APACHE_THRIFT_ACCESSOR_leader +APACHE_THRIFT_DEFINE_ACCESSOR(leader); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_listeners +#define APACHE_THRIFT_ACCESSOR_listeners +APACHE_THRIFT_DEFINE_ACCESSOR(listeners); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_space_id +#define APACHE_THRIFT_ACCESSOR_space_id +APACHE_THRIFT_DEFINE_ACCESSOR(space_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_code +#define APACHE_THRIFT_ACCESSOR_code +APACHE_THRIFT_DEFINE_ACCESSOR(code); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_leader +#define APACHE_THRIFT_ACCESSOR_leader +APACHE_THRIFT_DEFINE_ACCESSOR(leader); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_stats +#define APACHE_THRIFT_ACCESSOR_stats +APACHE_THRIFT_DEFINE_ACCESSOR(stats); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_host +#define APACHE_THRIFT_ACCESSOR_host +APACHE_THRIFT_DEFINE_ACCESSOR(host); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_info +#define APACHE_THRIFT_ACCESSOR_info +APACHE_THRIFT_DEFINE_ACCESSOR(info); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_space +#define APACHE_THRIFT_ACCESSOR_space +APACHE_THRIFT_DEFINE_ACCESSOR(space); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_info +#define APACHE_THRIFT_ACCESSOR_info +APACHE_THRIFT_DEFINE_ACCESSOR(info); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_backup_info +#define APACHE_THRIFT_ACCESSOR_backup_info +APACHE_THRIFT_DEFINE_ACCESSOR(backup_info); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_meta_files +#define APACHE_THRIFT_ACCESSOR_meta_files +APACHE_THRIFT_DEFINE_ACCESSOR(meta_files); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_backup_name +#define APACHE_THRIFT_ACCESSOR_backup_name +APACHE_THRIFT_DEFINE_ACCESSOR(backup_name); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_full +#define APACHE_THRIFT_ACCESSOR_full +APACHE_THRIFT_DEFINE_ACCESSOR(full); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_include_system_space +#define APACHE_THRIFT_ACCESSOR_include_system_space +APACHE_THRIFT_DEFINE_ACCESSOR(include_system_space); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_create_time +#define APACHE_THRIFT_ACCESSOR_create_time +APACHE_THRIFT_DEFINE_ACCESSOR(create_time); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_spaces +#define APACHE_THRIFT_ACCESSOR_spaces +APACHE_THRIFT_DEFINE_ACCESSOR(spaces); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_code +#define APACHE_THRIFT_ACCESSOR_code +APACHE_THRIFT_DEFINE_ACCESSOR(code); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_leader +#define APACHE_THRIFT_ACCESSOR_leader +APACHE_THRIFT_DEFINE_ACCESSOR(leader); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_meta +#define APACHE_THRIFT_ACCESSOR_meta +APACHE_THRIFT_DEFINE_ACCESSOR(meta); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_from_host +#define APACHE_THRIFT_ACCESSOR_from_host +APACHE_THRIFT_DEFINE_ACCESSOR(from_host); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_to_host +#define APACHE_THRIFT_ACCESSOR_to_host +APACHE_THRIFT_DEFINE_ACCESSOR(to_host); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_files +#define APACHE_THRIFT_ACCESSOR_files +APACHE_THRIFT_DEFINE_ACCESSOR(files); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_hosts +#define APACHE_THRIFT_ACCESSOR_hosts +APACHE_THRIFT_DEFINE_ACCESSOR(hosts); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_host +#define APACHE_THRIFT_ACCESSOR_host +APACHE_THRIFT_DEFINE_ACCESSOR(host); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_user +#define APACHE_THRIFT_ACCESSOR_user +APACHE_THRIFT_DEFINE_ACCESSOR(user); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_pwd +#define APACHE_THRIFT_ACCESSOR_pwd +APACHE_THRIFT_DEFINE_ACCESSOR(pwd); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_type +#define APACHE_THRIFT_ACCESSOR_type +APACHE_THRIFT_DEFINE_ACCESSOR(type); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_clients +#define APACHE_THRIFT_ACCESSOR_clients +APACHE_THRIFT_DEFINE_ACCESSOR(clients); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_code +#define APACHE_THRIFT_ACCESSOR_code +APACHE_THRIFT_DEFINE_ACCESSOR(code); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_leader +#define APACHE_THRIFT_ACCESSOR_leader +APACHE_THRIFT_DEFINE_ACCESSOR(leader); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_clients +#define APACHE_THRIFT_ACCESSOR_clients +APACHE_THRIFT_DEFINE_ACCESSOR(clients); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_space_id +#define APACHE_THRIFT_ACCESSOR_space_id +APACHE_THRIFT_DEFINE_ACCESSOR(space_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_depend_schema +#define APACHE_THRIFT_ACCESSOR_depend_schema +APACHE_THRIFT_DEFINE_ACCESSOR(depend_schema); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_fields +#define APACHE_THRIFT_ACCESSOR_fields +APACHE_THRIFT_DEFINE_ACCESSOR(fields); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_fulltext_index_name +#define APACHE_THRIFT_ACCESSOR_fulltext_index_name +APACHE_THRIFT_DEFINE_ACCESSOR(fulltext_index_name); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_index +#define APACHE_THRIFT_ACCESSOR_index +APACHE_THRIFT_DEFINE_ACCESSOR(index); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_space_id +#define APACHE_THRIFT_ACCESSOR_space_id +APACHE_THRIFT_DEFINE_ACCESSOR(space_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_fulltext_index_name +#define APACHE_THRIFT_ACCESSOR_fulltext_index_name +APACHE_THRIFT_DEFINE_ACCESSOR(fulltext_index_name); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_code +#define APACHE_THRIFT_ACCESSOR_code +APACHE_THRIFT_DEFINE_ACCESSOR(code); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_leader +#define APACHE_THRIFT_ACCESSOR_leader +APACHE_THRIFT_DEFINE_ACCESSOR(leader); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_indexes +#define APACHE_THRIFT_ACCESSOR_indexes +APACHE_THRIFT_DEFINE_ACCESSOR(indexes); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_start_time +#define APACHE_THRIFT_ACCESSOR_start_time +APACHE_THRIFT_DEFINE_ACCESSOR(start_time); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_status +#define APACHE_THRIFT_ACCESSOR_status +APACHE_THRIFT_DEFINE_ACCESSOR(status); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_duration +#define APACHE_THRIFT_ACCESSOR_duration +APACHE_THRIFT_DEFINE_ACCESSOR(duration); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_query +#define APACHE_THRIFT_ACCESSOR_query +APACHE_THRIFT_DEFINE_ACCESSOR(query); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_graph_addr +#define APACHE_THRIFT_ACCESSOR_graph_addr +APACHE_THRIFT_DEFINE_ACCESSOR(graph_addr); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_session_id +#define APACHE_THRIFT_ACCESSOR_session_id +APACHE_THRIFT_DEFINE_ACCESSOR(session_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_create_time +#define APACHE_THRIFT_ACCESSOR_create_time +APACHE_THRIFT_DEFINE_ACCESSOR(create_time); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_update_time +#define APACHE_THRIFT_ACCESSOR_update_time +APACHE_THRIFT_DEFINE_ACCESSOR(update_time); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_user_name +#define APACHE_THRIFT_ACCESSOR_user_name +APACHE_THRIFT_DEFINE_ACCESSOR(user_name); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_space_name +#define APACHE_THRIFT_ACCESSOR_space_name +APACHE_THRIFT_DEFINE_ACCESSOR(space_name); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_graph_addr +#define APACHE_THRIFT_ACCESSOR_graph_addr +APACHE_THRIFT_DEFINE_ACCESSOR(graph_addr); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_timezone +#define APACHE_THRIFT_ACCESSOR_timezone +APACHE_THRIFT_DEFINE_ACCESSOR(timezone); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_client_ip +#define APACHE_THRIFT_ACCESSOR_client_ip +APACHE_THRIFT_DEFINE_ACCESSOR(client_ip); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_configs +#define APACHE_THRIFT_ACCESSOR_configs +APACHE_THRIFT_DEFINE_ACCESSOR(configs); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_queries +#define APACHE_THRIFT_ACCESSOR_queries +APACHE_THRIFT_DEFINE_ACCESSOR(queries); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_user +#define APACHE_THRIFT_ACCESSOR_user +APACHE_THRIFT_DEFINE_ACCESSOR(user); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_graph_addr +#define APACHE_THRIFT_ACCESSOR_graph_addr +APACHE_THRIFT_DEFINE_ACCESSOR(graph_addr); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_client_ip +#define APACHE_THRIFT_ACCESSOR_client_ip +APACHE_THRIFT_DEFINE_ACCESSOR(client_ip); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_code +#define APACHE_THRIFT_ACCESSOR_code +APACHE_THRIFT_DEFINE_ACCESSOR(code); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_leader +#define APACHE_THRIFT_ACCESSOR_leader +APACHE_THRIFT_DEFINE_ACCESSOR(leader); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_session +#define APACHE_THRIFT_ACCESSOR_session +APACHE_THRIFT_DEFINE_ACCESSOR(session); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_sessions +#define APACHE_THRIFT_ACCESSOR_sessions +APACHE_THRIFT_DEFINE_ACCESSOR(sessions); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_code +#define APACHE_THRIFT_ACCESSOR_code +APACHE_THRIFT_DEFINE_ACCESSOR(code); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_leader +#define APACHE_THRIFT_ACCESSOR_leader +APACHE_THRIFT_DEFINE_ACCESSOR(leader); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_killed_queries +#define APACHE_THRIFT_ACCESSOR_killed_queries +APACHE_THRIFT_DEFINE_ACCESSOR(killed_queries); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_code +#define APACHE_THRIFT_ACCESSOR_code +APACHE_THRIFT_DEFINE_ACCESSOR(code); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_leader +#define APACHE_THRIFT_ACCESSOR_leader +APACHE_THRIFT_DEFINE_ACCESSOR(leader); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_sessions +#define APACHE_THRIFT_ACCESSOR_sessions +APACHE_THRIFT_DEFINE_ACCESSOR(sessions); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_session_id +#define APACHE_THRIFT_ACCESSOR_session_id +APACHE_THRIFT_DEFINE_ACCESSOR(session_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_code +#define APACHE_THRIFT_ACCESSOR_code +APACHE_THRIFT_DEFINE_ACCESSOR(code); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_leader +#define APACHE_THRIFT_ACCESSOR_leader +APACHE_THRIFT_DEFINE_ACCESSOR(leader); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_session +#define APACHE_THRIFT_ACCESSOR_session +APACHE_THRIFT_DEFINE_ACCESSOR(session); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_session_id +#define APACHE_THRIFT_ACCESSOR_session_id +APACHE_THRIFT_DEFINE_ACCESSOR(session_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_kill_queries +#define APACHE_THRIFT_ACCESSOR_kill_queries +APACHE_THRIFT_DEFINE_ACCESSOR(kill_queries); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_code +#define APACHE_THRIFT_ACCESSOR_code +APACHE_THRIFT_DEFINE_ACCESSOR(code); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_job_id +#define APACHE_THRIFT_ACCESSOR_job_id +APACHE_THRIFT_DEFINE_ACCESSOR(job_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_task_id +#define APACHE_THRIFT_ACCESSOR_task_id +APACHE_THRIFT_DEFINE_ACCESSOR(task_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_stats +#define APACHE_THRIFT_ACCESSOR_stats +APACHE_THRIFT_DEFINE_ACCESSOR(stats); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_code +#define APACHE_THRIFT_ACCESSOR_code +APACHE_THRIFT_DEFINE_ACCESSOR(code); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_leader +#define APACHE_THRIFT_ACCESSOR_leader +APACHE_THRIFT_DEFINE_ACCESSOR(leader); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_meta_servers +#define APACHE_THRIFT_ACCESSOR_meta_servers +APACHE_THRIFT_DEFINE_ACCESSOR(meta_servers); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_storage_servers +#define APACHE_THRIFT_ACCESSOR_storage_servers +APACHE_THRIFT_DEFINE_ACCESSOR(storage_servers); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_code +#define APACHE_THRIFT_ACCESSOR_code +APACHE_THRIFT_DEFINE_ACCESSOR(code); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_dir +#define APACHE_THRIFT_ACCESSOR_dir +APACHE_THRIFT_DEFINE_ACCESSOR(dir); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_code +#define APACHE_THRIFT_ACCESSOR_code +APACHE_THRIFT_DEFINE_ACCESSOR(code); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_leader +#define APACHE_THRIFT_ACCESSOR_leader +APACHE_THRIFT_DEFINE_ACCESSOR(leader); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_error_msg +#define APACHE_THRIFT_ACCESSOR_error_msg +APACHE_THRIFT_DEFINE_ACCESSOR(error_msg); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_version +#define APACHE_THRIFT_ACCESSOR_version +APACHE_THRIFT_DEFINE_ACCESSOR(version); +#endif +} // namespace detail +} // namespace thrift +} // namespace apache + +// BEGIN declare_enums +namespace nebula { namespace meta { namespace cpp2 { + +enum class AlterSchemaOp { + ADD = 1, + CHANGE = 2, + DROP = 3, + UNKNOWN = 4, +}; + + + + +enum class RoleType { + GOD = 1, + ADMIN = 2, + DBA = 3, + USER = 4, + GUEST = 5, +}; + + + + +enum class GeoShape { + ANY = 0, + POINT = 1, + LINESTRING = 2, + POLYGON = 3, +}; + + + + +enum class PropertyType { + UNKNOWN = 0, + BOOL = 1, + INT64 = 2, + VID = 3, + FLOAT = 4, + DOUBLE = 5, + STRING = 6, + FIXED_STRING = 7, + INT8 = 8, + INT16 = 9, + INT32 = 10, + TIMESTAMP = 21, + DATE = 24, + DATETIME = 25, + TIME = 26, + GEOGRAPHY = 31, +}; + + + + +enum class IsolationLevel { + DEFAULT = 0, + TOSS = 1, +}; + + + + +enum class HostStatus { + ONLINE = 0, + OFFLINE = 1, + UNKNOWN = 2, +}; + + + + +enum class SnapshotStatus { + VALID = 0, + INVALID = 1, +}; + + + + +enum class AdminJobOp { + ADD = 1, + SHOW_All = 2, + SHOW = 3, + STOP = 4, + RECOVER = 5, +}; + + + + +enum class AdminCmd { + COMPACT = 0, + FLUSH = 1, + REBUILD_TAG_INDEX = 2, + REBUILD_EDGE_INDEX = 3, + REBUILD_FULLTEXT_INDEX = 4, + STATS = 5, + DATA_BALANCE = 6, + DOWNLOAD = 7, + INGEST = 8, + UNKNOWN = 99, +}; + + + + +enum class JobStatus { + QUEUE = 1, + RUNNING = 2, + FINISHED = 3, + FAILED = 4, + STOPPED = 5, + INVALID = 255, +}; + + + + +enum class ListHostType { + ALLOC = 0, + GRAPH = 1, + META = 2, + STORAGE = 3, +}; + + + + +enum class HostRole { + GRAPH = 0, + META = 1, + STORAGE = 2, + LISTENER = 3, + UNKNOWN = 4, +}; + + + + +enum class TaskResult { + SUCCEEDED = 0, + FAILED = 1, + IN_PROGRESS = 2, + INVALID = 3, +}; + + + + +enum class ConfigModule { + UNKNOWN = 0, + ALL = 1, + GRAPH = 2, + META = 3, + STORAGE = 4, +}; + + + + +enum class ConfigMode { + IMMUTABLE = 0, + REBOOT = 1, + MUTABLE = 2, + IGNORED = 3, +}; + + + + +enum class ListenerType { + UNKNOWN = 0, + ELASTICSEARCH = 1, +}; + + + + +enum class FTServiceType { + ELASTICSEARCH = 1, +}; + + + + +enum class QueryStatus { + RUNNING = 1, + KILLING = 2, +}; + + + + +}}} // nebula::meta::cpp2 +namespace std { + + +template<> struct hash : public apache::thrift::detail::enum_hash {}; +template<> struct equal_to : public apache::thrift::detail::enum_equal_to {}; + + +template<> struct hash : public apache::thrift::detail::enum_hash {}; +template<> struct equal_to : public apache::thrift::detail::enum_equal_to {}; + + +template<> struct hash : public apache::thrift::detail::enum_hash {}; +template<> struct equal_to : public apache::thrift::detail::enum_equal_to {}; + + +template<> struct hash : public apache::thrift::detail::enum_hash {}; +template<> struct equal_to : public apache::thrift::detail::enum_equal_to {}; + + +template<> struct hash : public apache::thrift::detail::enum_hash {}; +template<> struct equal_to : public apache::thrift::detail::enum_equal_to {}; + + +template<> struct hash : public apache::thrift::detail::enum_hash {}; +template<> struct equal_to : public apache::thrift::detail::enum_equal_to {}; + + +template<> struct hash : public apache::thrift::detail::enum_hash {}; +template<> struct equal_to : public apache::thrift::detail::enum_equal_to {}; + + +template<> struct hash : public apache::thrift::detail::enum_hash {}; +template<> struct equal_to : public apache::thrift::detail::enum_equal_to {}; + + +template<> struct hash : public apache::thrift::detail::enum_hash {}; +template<> struct equal_to : public apache::thrift::detail::enum_equal_to {}; + + +template<> struct hash : public apache::thrift::detail::enum_hash {}; +template<> struct equal_to : public apache::thrift::detail::enum_equal_to {}; + + +template<> struct hash : public apache::thrift::detail::enum_hash {}; +template<> struct equal_to : public apache::thrift::detail::enum_equal_to {}; + + +template<> struct hash : public apache::thrift::detail::enum_hash {}; +template<> struct equal_to : public apache::thrift::detail::enum_equal_to {}; + + +template<> struct hash : public apache::thrift::detail::enum_hash {}; +template<> struct equal_to : public apache::thrift::detail::enum_equal_to {}; + + +template<> struct hash : public apache::thrift::detail::enum_hash {}; +template<> struct equal_to : public apache::thrift::detail::enum_equal_to {}; + + +template<> struct hash : public apache::thrift::detail::enum_hash {}; +template<> struct equal_to : public apache::thrift::detail::enum_equal_to {}; + + +template<> struct hash : public apache::thrift::detail::enum_hash {}; +template<> struct equal_to : public apache::thrift::detail::enum_equal_to {}; + + +template<> struct hash : public apache::thrift::detail::enum_hash {}; +template<> struct equal_to : public apache::thrift::detail::enum_equal_to {}; + + +template<> struct hash : public apache::thrift::detail::enum_hash {}; +template<> struct equal_to : public apache::thrift::detail::enum_equal_to {}; + + +} // std + +namespace apache { namespace thrift { + + +template <> struct TEnumDataStorage<::nebula::meta::cpp2::AlterSchemaOp>; + +template <> struct TEnumTraits<::nebula::meta::cpp2::AlterSchemaOp> { + using type = ::nebula::meta::cpp2::AlterSchemaOp; + + static constexpr std::size_t const size = 4; + static folly::Range const values; + static folly::Range const names; + + static char const* findName(type value); + static bool findValue(char const* name, type* out); + + static constexpr type min() { return type::ADD; } + static constexpr type max() { return type::UNKNOWN; } +}; + + +template <> struct TEnumDataStorage<::nebula::meta::cpp2::RoleType>; + +template <> struct TEnumTraits<::nebula::meta::cpp2::RoleType> { + using type = ::nebula::meta::cpp2::RoleType; + + static constexpr std::size_t const size = 5; + static folly::Range const values; + static folly::Range const names; + + static char const* findName(type value); + static bool findValue(char const* name, type* out); + + static constexpr type min() { return type::GOD; } + static constexpr type max() { return type::GUEST; } +}; + + +template <> struct TEnumDataStorage<::nebula::meta::cpp2::GeoShape>; + +template <> struct TEnumTraits<::nebula::meta::cpp2::GeoShape> { + using type = ::nebula::meta::cpp2::GeoShape; + + static constexpr std::size_t const size = 4; + static folly::Range const values; + static folly::Range const names; + + static char const* findName(type value); + static bool findValue(char const* name, type* out); + + static constexpr type min() { return type::ANY; } + static constexpr type max() { return type::POLYGON; } +}; + + +template <> struct TEnumDataStorage<::nebula::meta::cpp2::PropertyType>; + +template <> struct TEnumTraits<::nebula::meta::cpp2::PropertyType> { + using type = ::nebula::meta::cpp2::PropertyType; + + static constexpr std::size_t const size = 16; + static folly::Range const values; + static folly::Range const names; + + static char const* findName(type value); + static bool findValue(char const* name, type* out); + + static constexpr type min() { return type::UNKNOWN; } + static constexpr type max() { return type::GEOGRAPHY; } +}; + + +template <> struct TEnumDataStorage<::nebula::meta::cpp2::IsolationLevel>; + +template <> struct TEnumTraits<::nebula::meta::cpp2::IsolationLevel> { + using type = ::nebula::meta::cpp2::IsolationLevel; + + static constexpr std::size_t const size = 2; + static folly::Range const values; + static folly::Range const names; + + static char const* findName(type value); + static bool findValue(char const* name, type* out); + + static constexpr type min() { return type::DEFAULT; } + static constexpr type max() { return type::TOSS; } +}; + + +template <> struct TEnumDataStorage<::nebula::meta::cpp2::HostStatus>; + +template <> struct TEnumTraits<::nebula::meta::cpp2::HostStatus> { + using type = ::nebula::meta::cpp2::HostStatus; + + static constexpr std::size_t const size = 3; + static folly::Range const values; + static folly::Range const names; + + static char const* findName(type value); + static bool findValue(char const* name, type* out); + + static constexpr type min() { return type::ONLINE; } + static constexpr type max() { return type::UNKNOWN; } +}; + + +template <> struct TEnumDataStorage<::nebula::meta::cpp2::SnapshotStatus>; + +template <> struct TEnumTraits<::nebula::meta::cpp2::SnapshotStatus> { + using type = ::nebula::meta::cpp2::SnapshotStatus; + + static constexpr std::size_t const size = 2; + static folly::Range const values; + static folly::Range const names; + + static char const* findName(type value); + static bool findValue(char const* name, type* out); + + static constexpr type min() { return type::VALID; } + static constexpr type max() { return type::INVALID; } +}; + + +template <> struct TEnumDataStorage<::nebula::meta::cpp2::AdminJobOp>; + +template <> struct TEnumTraits<::nebula::meta::cpp2::AdminJobOp> { + using type = ::nebula::meta::cpp2::AdminJobOp; + + static constexpr std::size_t const size = 5; + static folly::Range const values; + static folly::Range const names; + + static char const* findName(type value); + static bool findValue(char const* name, type* out); + + static constexpr type min() { return type::ADD; } + static constexpr type max() { return type::RECOVER; } +}; + + +template <> struct TEnumDataStorage<::nebula::meta::cpp2::AdminCmd>; + +template <> struct TEnumTraits<::nebula::meta::cpp2::AdminCmd> { + using type = ::nebula::meta::cpp2::AdminCmd; + + static constexpr std::size_t const size = 10; + static folly::Range const values; + static folly::Range const names; + + static char const* findName(type value); + static bool findValue(char const* name, type* out); + + static constexpr type min() { return type::COMPACT; } + static constexpr type max() { return type::UNKNOWN; } +}; + + +template <> struct TEnumDataStorage<::nebula::meta::cpp2::JobStatus>; + +template <> struct TEnumTraits<::nebula::meta::cpp2::JobStatus> { + using type = ::nebula::meta::cpp2::JobStatus; + + static constexpr std::size_t const size = 6; + static folly::Range const values; + static folly::Range const names; + + static char const* findName(type value); + static bool findValue(char const* name, type* out); + + static constexpr type min() { return type::QUEUE; } + static constexpr type max() { return type::INVALID; } +}; + + +template <> struct TEnumDataStorage<::nebula::meta::cpp2::ListHostType>; + +template <> struct TEnumTraits<::nebula::meta::cpp2::ListHostType> { + using type = ::nebula::meta::cpp2::ListHostType; + + static constexpr std::size_t const size = 4; + static folly::Range const values; + static folly::Range const names; + + static char const* findName(type value); + static bool findValue(char const* name, type* out); + + static constexpr type min() { return type::ALLOC; } + static constexpr type max() { return type::STORAGE; } +}; + + +template <> struct TEnumDataStorage<::nebula::meta::cpp2::HostRole>; + +template <> struct TEnumTraits<::nebula::meta::cpp2::HostRole> { + using type = ::nebula::meta::cpp2::HostRole; + + static constexpr std::size_t const size = 5; + static folly::Range const values; + static folly::Range const names; + + static char const* findName(type value); + static bool findValue(char const* name, type* out); + + static constexpr type min() { return type::GRAPH; } + static constexpr type max() { return type::UNKNOWN; } +}; + + +template <> struct TEnumDataStorage<::nebula::meta::cpp2::TaskResult>; + +template <> struct TEnumTraits<::nebula::meta::cpp2::TaskResult> { + using type = ::nebula::meta::cpp2::TaskResult; + + static constexpr std::size_t const size = 4; + static folly::Range const values; + static folly::Range const names; + + static char const* findName(type value); + static bool findValue(char const* name, type* out); + + static constexpr type min() { return type::SUCCEEDED; } + static constexpr type max() { return type::INVALID; } +}; + + +template <> struct TEnumDataStorage<::nebula::meta::cpp2::ConfigModule>; + +template <> struct TEnumTraits<::nebula::meta::cpp2::ConfigModule> { + using type = ::nebula::meta::cpp2::ConfigModule; + + static constexpr std::size_t const size = 5; + static folly::Range const values; + static folly::Range const names; + + static char const* findName(type value); + static bool findValue(char const* name, type* out); + + static constexpr type min() { return type::UNKNOWN; } + static constexpr type max() { return type::STORAGE; } +}; + + +template <> struct TEnumDataStorage<::nebula::meta::cpp2::ConfigMode>; + +template <> struct TEnumTraits<::nebula::meta::cpp2::ConfigMode> { + using type = ::nebula::meta::cpp2::ConfigMode; + + static constexpr std::size_t const size = 4; + static folly::Range const values; + static folly::Range const names; + + static char const* findName(type value); + static bool findValue(char const* name, type* out); + + static constexpr type min() { return type::IMMUTABLE; } + static constexpr type max() { return type::IGNORED; } +}; + + +template <> struct TEnumDataStorage<::nebula::meta::cpp2::ListenerType>; + +template <> struct TEnumTraits<::nebula::meta::cpp2::ListenerType> { + using type = ::nebula::meta::cpp2::ListenerType; + + static constexpr std::size_t const size = 2; + static folly::Range const values; + static folly::Range const names; + + static char const* findName(type value); + static bool findValue(char const* name, type* out); + + static constexpr type min() { return type::UNKNOWN; } + static constexpr type max() { return type::ELASTICSEARCH; } +}; + + +template <> struct TEnumDataStorage<::nebula::meta::cpp2::FTServiceType>; + +template <> struct TEnumTraits<::nebula::meta::cpp2::FTServiceType> { + using type = ::nebula::meta::cpp2::FTServiceType; + + static constexpr std::size_t const size = 1; + static folly::Range const values; + static folly::Range const names; + + static char const* findName(type value); + static bool findValue(char const* name, type* out); + + static constexpr type min() { return type::ELASTICSEARCH; } + static constexpr type max() { return type::ELASTICSEARCH; } +}; + + +template <> struct TEnumDataStorage<::nebula::meta::cpp2::QueryStatus>; + +template <> struct TEnumTraits<::nebula::meta::cpp2::QueryStatus> { + using type = ::nebula::meta::cpp2::QueryStatus; + + static constexpr std::size_t const size = 2; + static folly::Range const values; + static folly::Range const names; + + static char const* findName(type value); + static bool findValue(char const* name, type* out); + + static constexpr type min() { return type::RUNNING; } + static constexpr type max() { return type::KILLING; } +}; + + +}} // apache::thrift + +namespace nebula { namespace meta { namespace cpp2 { + +using _AlterSchemaOp_EnumMapFactory = apache::thrift::detail::TEnumMapFactory; +[[deprecated("use apache::thrift::util::enumNameSafe, apache::thrift::util::enumName, or apache::thrift::TEnumTraits")]] +extern const _AlterSchemaOp_EnumMapFactory::ValuesToNamesMapType _AlterSchemaOp_VALUES_TO_NAMES; +[[deprecated("use apache::thrift::TEnumTraits")]] +extern const _AlterSchemaOp_EnumMapFactory::NamesToValuesMapType _AlterSchemaOp_NAMES_TO_VALUES; + +using _RoleType_EnumMapFactory = apache::thrift::detail::TEnumMapFactory; +[[deprecated("use apache::thrift::util::enumNameSafe, apache::thrift::util::enumName, or apache::thrift::TEnumTraits")]] +extern const _RoleType_EnumMapFactory::ValuesToNamesMapType _RoleType_VALUES_TO_NAMES; +[[deprecated("use apache::thrift::TEnumTraits")]] +extern const _RoleType_EnumMapFactory::NamesToValuesMapType _RoleType_NAMES_TO_VALUES; + +using _GeoShape_EnumMapFactory = apache::thrift::detail::TEnumMapFactory; +[[deprecated("use apache::thrift::util::enumNameSafe, apache::thrift::util::enumName, or apache::thrift::TEnumTraits")]] +extern const _GeoShape_EnumMapFactory::ValuesToNamesMapType _GeoShape_VALUES_TO_NAMES; +[[deprecated("use apache::thrift::TEnumTraits")]] +extern const _GeoShape_EnumMapFactory::NamesToValuesMapType _GeoShape_NAMES_TO_VALUES; + +using _PropertyType_EnumMapFactory = apache::thrift::detail::TEnumMapFactory; +[[deprecated("use apache::thrift::util::enumNameSafe, apache::thrift::util::enumName, or apache::thrift::TEnumTraits")]] +extern const _PropertyType_EnumMapFactory::ValuesToNamesMapType _PropertyType_VALUES_TO_NAMES; +[[deprecated("use apache::thrift::TEnumTraits")]] +extern const _PropertyType_EnumMapFactory::NamesToValuesMapType _PropertyType_NAMES_TO_VALUES; + +using _IsolationLevel_EnumMapFactory = apache::thrift::detail::TEnumMapFactory; +[[deprecated("use apache::thrift::util::enumNameSafe, apache::thrift::util::enumName, or apache::thrift::TEnumTraits")]] +extern const _IsolationLevel_EnumMapFactory::ValuesToNamesMapType _IsolationLevel_VALUES_TO_NAMES; +[[deprecated("use apache::thrift::TEnumTraits")]] +extern const _IsolationLevel_EnumMapFactory::NamesToValuesMapType _IsolationLevel_NAMES_TO_VALUES; + +using _HostStatus_EnumMapFactory = apache::thrift::detail::TEnumMapFactory; +[[deprecated("use apache::thrift::util::enumNameSafe, apache::thrift::util::enumName, or apache::thrift::TEnumTraits")]] +extern const _HostStatus_EnumMapFactory::ValuesToNamesMapType _HostStatus_VALUES_TO_NAMES; +[[deprecated("use apache::thrift::TEnumTraits")]] +extern const _HostStatus_EnumMapFactory::NamesToValuesMapType _HostStatus_NAMES_TO_VALUES; + +using _SnapshotStatus_EnumMapFactory = apache::thrift::detail::TEnumMapFactory; +[[deprecated("use apache::thrift::util::enumNameSafe, apache::thrift::util::enumName, or apache::thrift::TEnumTraits")]] +extern const _SnapshotStatus_EnumMapFactory::ValuesToNamesMapType _SnapshotStatus_VALUES_TO_NAMES; +[[deprecated("use apache::thrift::TEnumTraits")]] +extern const _SnapshotStatus_EnumMapFactory::NamesToValuesMapType _SnapshotStatus_NAMES_TO_VALUES; + +using _AdminJobOp_EnumMapFactory = apache::thrift::detail::TEnumMapFactory; +[[deprecated("use apache::thrift::util::enumNameSafe, apache::thrift::util::enumName, or apache::thrift::TEnumTraits")]] +extern const _AdminJobOp_EnumMapFactory::ValuesToNamesMapType _AdminJobOp_VALUES_TO_NAMES; +[[deprecated("use apache::thrift::TEnumTraits")]] +extern const _AdminJobOp_EnumMapFactory::NamesToValuesMapType _AdminJobOp_NAMES_TO_VALUES; + +using _AdminCmd_EnumMapFactory = apache::thrift::detail::TEnumMapFactory; +[[deprecated("use apache::thrift::util::enumNameSafe, apache::thrift::util::enumName, or apache::thrift::TEnumTraits")]] +extern const _AdminCmd_EnumMapFactory::ValuesToNamesMapType _AdminCmd_VALUES_TO_NAMES; +[[deprecated("use apache::thrift::TEnumTraits")]] +extern const _AdminCmd_EnumMapFactory::NamesToValuesMapType _AdminCmd_NAMES_TO_VALUES; + +using _JobStatus_EnumMapFactory = apache::thrift::detail::TEnumMapFactory; +[[deprecated("use apache::thrift::util::enumNameSafe, apache::thrift::util::enumName, or apache::thrift::TEnumTraits")]] +extern const _JobStatus_EnumMapFactory::ValuesToNamesMapType _JobStatus_VALUES_TO_NAMES; +[[deprecated("use apache::thrift::TEnumTraits")]] +extern const _JobStatus_EnumMapFactory::NamesToValuesMapType _JobStatus_NAMES_TO_VALUES; + +using _ListHostType_EnumMapFactory = apache::thrift::detail::TEnumMapFactory; +[[deprecated("use apache::thrift::util::enumNameSafe, apache::thrift::util::enumName, or apache::thrift::TEnumTraits")]] +extern const _ListHostType_EnumMapFactory::ValuesToNamesMapType _ListHostType_VALUES_TO_NAMES; +[[deprecated("use apache::thrift::TEnumTraits")]] +extern const _ListHostType_EnumMapFactory::NamesToValuesMapType _ListHostType_NAMES_TO_VALUES; + +using _HostRole_EnumMapFactory = apache::thrift::detail::TEnumMapFactory; +[[deprecated("use apache::thrift::util::enumNameSafe, apache::thrift::util::enumName, or apache::thrift::TEnumTraits")]] +extern const _HostRole_EnumMapFactory::ValuesToNamesMapType _HostRole_VALUES_TO_NAMES; +[[deprecated("use apache::thrift::TEnumTraits")]] +extern const _HostRole_EnumMapFactory::NamesToValuesMapType _HostRole_NAMES_TO_VALUES; + +using _TaskResult_EnumMapFactory = apache::thrift::detail::TEnumMapFactory; +[[deprecated("use apache::thrift::util::enumNameSafe, apache::thrift::util::enumName, or apache::thrift::TEnumTraits")]] +extern const _TaskResult_EnumMapFactory::ValuesToNamesMapType _TaskResult_VALUES_TO_NAMES; +[[deprecated("use apache::thrift::TEnumTraits")]] +extern const _TaskResult_EnumMapFactory::NamesToValuesMapType _TaskResult_NAMES_TO_VALUES; + +using _ConfigModule_EnumMapFactory = apache::thrift::detail::TEnumMapFactory; +[[deprecated("use apache::thrift::util::enumNameSafe, apache::thrift::util::enumName, or apache::thrift::TEnumTraits")]] +extern const _ConfigModule_EnumMapFactory::ValuesToNamesMapType _ConfigModule_VALUES_TO_NAMES; +[[deprecated("use apache::thrift::TEnumTraits")]] +extern const _ConfigModule_EnumMapFactory::NamesToValuesMapType _ConfigModule_NAMES_TO_VALUES; + +using _ConfigMode_EnumMapFactory = apache::thrift::detail::TEnumMapFactory; +[[deprecated("use apache::thrift::util::enumNameSafe, apache::thrift::util::enumName, or apache::thrift::TEnumTraits")]] +extern const _ConfigMode_EnumMapFactory::ValuesToNamesMapType _ConfigMode_VALUES_TO_NAMES; +[[deprecated("use apache::thrift::TEnumTraits")]] +extern const _ConfigMode_EnumMapFactory::NamesToValuesMapType _ConfigMode_NAMES_TO_VALUES; + +using _ListenerType_EnumMapFactory = apache::thrift::detail::TEnumMapFactory; +[[deprecated("use apache::thrift::util::enumNameSafe, apache::thrift::util::enumName, or apache::thrift::TEnumTraits")]] +extern const _ListenerType_EnumMapFactory::ValuesToNamesMapType _ListenerType_VALUES_TO_NAMES; +[[deprecated("use apache::thrift::TEnumTraits")]] +extern const _ListenerType_EnumMapFactory::NamesToValuesMapType _ListenerType_NAMES_TO_VALUES; + +using _FTServiceType_EnumMapFactory = apache::thrift::detail::TEnumMapFactory; +[[deprecated("use apache::thrift::util::enumNameSafe, apache::thrift::util::enumName, or apache::thrift::TEnumTraits")]] +extern const _FTServiceType_EnumMapFactory::ValuesToNamesMapType _FTServiceType_VALUES_TO_NAMES; +[[deprecated("use apache::thrift::TEnumTraits")]] +extern const _FTServiceType_EnumMapFactory::NamesToValuesMapType _FTServiceType_NAMES_TO_VALUES; + +using _QueryStatus_EnumMapFactory = apache::thrift::detail::TEnumMapFactory; +[[deprecated("use apache::thrift::util::enumNameSafe, apache::thrift::util::enumName, or apache::thrift::TEnumTraits")]] +extern const _QueryStatus_EnumMapFactory::ValuesToNamesMapType _QueryStatus_VALUES_TO_NAMES; +[[deprecated("use apache::thrift::TEnumTraits")]] +extern const _QueryStatus_EnumMapFactory::NamesToValuesMapType _QueryStatus_NAMES_TO_VALUES; + +}}} // nebula::meta::cpp2 + +// END declare_enums +// BEGIN forward_declare +namespace nebula { namespace meta { namespace cpp2 { +class ID; +class ColumnTypeDef; +class ColumnDef; +class SchemaProp; +class Schema; +class IdName; +class SpaceDesc; +class SpaceItem; +class TagItem; +class AlterSchemaItem; +class EdgeItem; +class IndexItem; +class HostItem; +class UserItem; +class RoleItem; +class ExecResp; +class AdminJobReq; +class JobDesc; +class TaskDesc; +class AdminJobResult; +class AdminJobResp; +class Correlativity; +class StatsItem; +class CreateSpaceReq; +class CreateSpaceAsReq; +class DropSpaceReq; +class ListSpacesReq; +class ListSpacesResp; +class GetSpaceReq; +class GetSpaceResp; +class CreateTagReq; +class AlterTagReq; +class DropTagReq; +class ListTagsReq; +class ListTagsResp; +class GetTagReq; +class GetTagResp; +class CreateEdgeReq; +class AlterEdgeReq; +class GetEdgeReq; +class GetEdgeResp; +class DropEdgeReq; +class ListEdgesReq; +class ListEdgesResp; +class ListHostsReq; +class ListHostsResp; +class PartItem; +class ListPartsReq; +class ListPartsResp; +class GetPartsAllocReq; +class GetPartsAllocResp; +class MultiPutReq; +class GetReq; +class GetResp; +class MultiGetReq; +class MultiGetResp; +class RemoveReq; +class RemoveRangeReq; +class ScanReq; +class ScanResp; +class HBResp; +class LeaderInfo; +class HBReq; +class IndexFieldDef; +class CreateTagIndexReq; +class DropTagIndexReq; +class GetTagIndexReq; +class GetTagIndexResp; +class ListTagIndexesReq; +class ListTagIndexesResp; +class CreateEdgeIndexReq; +class DropEdgeIndexReq; +class GetEdgeIndexReq; +class GetEdgeIndexResp; +class ListEdgeIndexesReq; +class ListEdgeIndexesResp; +class RebuildIndexReq; +class CreateUserReq; +class DropUserReq; +class AlterUserReq; +class GrantRoleReq; +class RevokeRoleReq; +class ListUsersReq; +class ListUsersResp; +class ListRolesReq; +class ListRolesResp; +class GetUserRolesReq; +class ChangePasswordReq; +class BalanceReq; +class BalanceTask; +class BalanceResp; +class LeaderBalanceReq; +class ConfigItem; +class RegConfigReq; +class GetConfigReq; +class GetConfigResp; +class SetConfigReq; +class ListConfigsReq; +class ListConfigsResp; +class CreateSnapshotReq; +class DropSnapshotReq; +class ListSnapshotsReq; +class Snapshot; +class ListSnapshotsResp; +class ListIndexStatusReq; +class IndexStatus; +class ListIndexStatusResp; +class AddZoneReq; +class DropZoneReq; +class AddHostIntoZoneReq; +class DropHostFromZoneReq; +class GetZoneReq; +class GetZoneResp; +class ListZonesReq; +class Zone; +class ListZonesResp; +class AddGroupReq; +class DropGroupReq; +class AddZoneIntoGroupReq; +class DropZoneFromGroupReq; +class GetGroupReq; +class GetGroupResp; +class ListGroupsReq; +class Group; +class ListGroupsResp; +class AddListenerReq; +class RemoveListenerReq; +class ListListenerReq; +class ListenerInfo; +class ListListenerResp; +class GetStatsReq; +class GetStatsResp; +class BackupInfo; +class SpaceBackupInfo; +class BackupMeta; +class CreateBackupReq; +class CreateBackupResp; +class HostPair; +class RestoreMetaReq; +class FTClient; +class SignInFTServiceReq; +class SignOutFTServiceReq; +class ListFTClientsReq; +class ListFTClientsResp; +class FTIndex; +class CreateFTIndexReq; +class DropFTIndexReq; +class ListFTIndexesReq; +class ListFTIndexesResp; +class QueryDesc; +class Session; +class CreateSessionReq; +class CreateSessionResp; +class UpdateSessionsReq; +class UpdateSessionsResp; +class ListSessionsReq; +class ListSessionsResp; +class GetSessionReq; +class GetSessionResp; +class RemoveSessionReq; +class KillQueryReq; +class ReportTaskReq; +class ListClusterInfoResp; +class ListClusterInfoReq; +class GetMetaDirInfoResp; +class GetMetaDirInfoReq; +class VerifyClientVersionResp; +class VerifyClientVersionReq; +}}} // nebula::meta::cpp2 +// END forward_declare +// BEGIN typedefs +namespace nebula { namespace meta { namespace cpp2 { +typedef nebula::SchemaVer SchemaVer; +typedef nebula::ClusterID ClusterID; + +}}} // nebula::meta::cpp2 +// END typedefs +// BEGIN hash_and_equal_to +// END hash_and_equal_to +namespace nebula { namespace meta { namespace cpp2 { +class ID final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = ID; + static constexpr bool __fbthrift_cpp2_is_union = + true; + + + public: + enum Type : int { + __EMPTY__ = 0, + space_id = 1, + tag_id = 2, + edge_type = 3, + index_id = 4, + cluster_id = 5, + } ; + + ID() + : type_(Type::__EMPTY__) {} + + ID(ID&& rhs) + : type_(Type::__EMPTY__) { + if (this == &rhs) { return; } + if (rhs.type_ == Type::__EMPTY__) { return; } + switch (rhs.type_) { + case Type::space_id: + { + set_space_id(std::move(rhs.value_.space_id)); + break; + } + case Type::tag_id: + { + set_tag_id(std::move(rhs.value_.tag_id)); + break; + } + case Type::edge_type: + { + set_edge_type(std::move(rhs.value_.edge_type)); + break; + } + case Type::index_id: + { + set_index_id(std::move(rhs.value_.index_id)); + break; + } + case Type::cluster_id: + { + set_cluster_id(std::move(rhs.value_.cluster_id)); + break; + } + default: + { + assert(false); + break; + } + } + rhs.__clear(); + } + + ID(const ID& rhs) + : type_(Type::__EMPTY__) { + if (this == &rhs) { return; } + if (rhs.type_ == Type::__EMPTY__) { return; } + switch (rhs.type_) { + case Type::space_id: + { + set_space_id(rhs.value_.space_id); + break; + } + case Type::tag_id: + { + set_tag_id(rhs.value_.tag_id); + break; + } + case Type::edge_type: + { + set_edge_type(rhs.value_.edge_type); + break; + } + case Type::index_id: + { + set_index_id(rhs.value_.index_id); + break; + } + case Type::cluster_id: + { + set_cluster_id(rhs.value_.cluster_id); + break; + } + default: + { + assert(false); + break; + } + } + } + + ID& operator=(ID&& rhs) { + if (this == &rhs) { return *this; } + __clear(); + if (rhs.type_ == Type::__EMPTY__) { return *this; } + switch (rhs.type_) { + case Type::space_id: + { + set_space_id(std::move(rhs.value_.space_id)); + break; + } + case Type::tag_id: + { + set_tag_id(std::move(rhs.value_.tag_id)); + break; + } + case Type::edge_type: + { + set_edge_type(std::move(rhs.value_.edge_type)); + break; + } + case Type::index_id: + { + set_index_id(std::move(rhs.value_.index_id)); + break; + } + case Type::cluster_id: + { + set_cluster_id(std::move(rhs.value_.cluster_id)); + break; + } + default: + { + assert(false); + break; + } + } + rhs.__clear(); + return *this; + } + + ID& operator=(const ID& rhs) { + if (this == &rhs) { return *this; } + __clear(); + if (rhs.type_ == Type::__EMPTY__) { return *this; } + switch (rhs.type_) { + case Type::space_id: + { + set_space_id(rhs.value_.space_id); + break; + } + case Type::tag_id: + { + set_tag_id(rhs.value_.tag_id); + break; + } + case Type::edge_type: + { + set_edge_type(rhs.value_.edge_type); + break; + } + case Type::index_id: + { + set_index_id(rhs.value_.index_id); + break; + } + case Type::cluster_id: + { + set_cluster_id(rhs.value_.cluster_id); + break; + } + default: + { + assert(false); + break; + } + } + return *this; + } + void __clear(); + + ~ID() { + __clear(); + } + union storage_type { + ::nebula::cpp2::GraphSpaceID space_id; + ::nebula::cpp2::TagID tag_id; + ::nebula::cpp2::EdgeType edge_type; + ::nebula::cpp2::IndexID index_id; + ::nebula::meta::cpp2::ClusterID cluster_id; + + storage_type() {} + ~storage_type() {} + } ; + bool operator==(const ID& rhs) const; +#ifndef SWIG + friend bool operator!=(const ID& __x, const ID& __y) { + return !(__x == __y); + } +#endif + bool operator<(const ID& rhs) const; +#ifndef SWIG + friend bool operator>(const ID& __x, const ID& __y) { + return __y < __x; + } + friend bool operator<=(const ID& __x, const ID& __y) { + return !(__y < __x); + } + friend bool operator>=(const ID& __x, const ID& __y) { + return !(__x < __y); + } +#endif + + ::nebula::cpp2::GraphSpaceID& set_space_id( ::nebula::cpp2::GraphSpaceID t = ::nebula::cpp2::GraphSpaceID()) { + __clear(); + type_ = Type::space_id; + ::new (std::addressof(value_.space_id)) ::nebula::cpp2::GraphSpaceID(t); + return value_.space_id; + } + + ::nebula::cpp2::TagID& set_tag_id( ::nebula::cpp2::TagID t = ::nebula::cpp2::TagID()) { + __clear(); + type_ = Type::tag_id; + ::new (std::addressof(value_.tag_id)) ::nebula::cpp2::TagID(t); + return value_.tag_id; + } + + ::nebula::cpp2::EdgeType& set_edge_type( ::nebula::cpp2::EdgeType t = ::nebula::cpp2::EdgeType()) { + __clear(); + type_ = Type::edge_type; + ::new (std::addressof(value_.edge_type)) ::nebula::cpp2::EdgeType(t); + return value_.edge_type; + } + + ::nebula::cpp2::IndexID& set_index_id( ::nebula::cpp2::IndexID t = ::nebula::cpp2::IndexID()) { + __clear(); + type_ = Type::index_id; + ::new (std::addressof(value_.index_id)) ::nebula::cpp2::IndexID(t); + return value_.index_id; + } + + ::nebula::meta::cpp2::ClusterID& set_cluster_id( ::nebula::meta::cpp2::ClusterID t = ::nebula::meta::cpp2::ClusterID()) { + __clear(); + type_ = Type::cluster_id; + ::new (std::addressof(value_.cluster_id)) ::nebula::meta::cpp2::ClusterID(t); + return value_.cluster_id; + } + + ::nebula::cpp2::GraphSpaceID const & get_space_id() const { + assert(type_ == Type::space_id); + return value_.space_id; + } + + ::nebula::cpp2::TagID const & get_tag_id() const { + assert(type_ == Type::tag_id); + return value_.tag_id; + } + + ::nebula::cpp2::EdgeType const & get_edge_type() const { + assert(type_ == Type::edge_type); + return value_.edge_type; + } + + ::nebula::cpp2::IndexID const & get_index_id() const { + assert(type_ == Type::index_id); + return value_.index_id; + } + + ::nebula::meta::cpp2::ClusterID const & get_cluster_id() const { + assert(type_ == Type::cluster_id); + return value_.cluster_id; + } + + ::nebula::cpp2::GraphSpaceID & mutable_space_id() { + assert(type_ == Type::space_id); + return value_.space_id; + } + + ::nebula::cpp2::TagID & mutable_tag_id() { + assert(type_ == Type::tag_id); + return value_.tag_id; + } + + ::nebula::cpp2::EdgeType & mutable_edge_type() { + assert(type_ == Type::edge_type); + return value_.edge_type; + } + + ::nebula::cpp2::IndexID & mutable_index_id() { + assert(type_ == Type::index_id); + return value_.index_id; + } + + ::nebula::meta::cpp2::ClusterID & mutable_cluster_id() { + assert(type_ == Type::cluster_id); + return value_.cluster_id; + } + + ::nebula::cpp2::GraphSpaceID move_space_id() { + assert(type_ == Type::space_id); + return std::move(value_.space_id); + } + + ::nebula::cpp2::TagID move_tag_id() { + assert(type_ == Type::tag_id); + return std::move(value_.tag_id); + } + + ::nebula::cpp2::EdgeType move_edge_type() { + assert(type_ == Type::edge_type); + return std::move(value_.edge_type); + } + + ::nebula::cpp2::IndexID move_index_id() { + assert(type_ == Type::index_id); + return std::move(value_.index_id); + } + + ::nebula::meta::cpp2::ClusterID move_cluster_id() { + assert(type_ == Type::cluster_id); + return std::move(value_.cluster_id); + } + + template + FOLLY_ERASE ::apache::thrift::union_field_ref space_id_ref() const& { + return {value_.space_id, type_, space_id, this, ::apache::thrift::detail::union_field_ref_owner_vtable_for}; + } + + template + FOLLY_ERASE ::apache::thrift::union_field_ref space_id_ref() const&& { + return {std::move(value_.space_id), type_, space_id, this, ::apache::thrift::detail::union_field_ref_owner_vtable_for}; + } + + template + FOLLY_ERASE ::apache::thrift::union_field_ref space_id_ref() & { + return {value_.space_id, type_, space_id, this, ::apache::thrift::detail::union_field_ref_owner_vtable_for}; + } + + template + FOLLY_ERASE ::apache::thrift::union_field_ref space_id_ref() && { + return {std::move(value_.space_id), type_, space_id, this, ::apache::thrift::detail::union_field_ref_owner_vtable_for}; + } + template + FOLLY_ERASE ::apache::thrift::union_field_ref tag_id_ref() const& { + return {value_.tag_id, type_, tag_id, this, ::apache::thrift::detail::union_field_ref_owner_vtable_for}; + } + + template + FOLLY_ERASE ::apache::thrift::union_field_ref tag_id_ref() const&& { + return {std::move(value_.tag_id), type_, tag_id, this, ::apache::thrift::detail::union_field_ref_owner_vtable_for}; + } + + template + FOLLY_ERASE ::apache::thrift::union_field_ref tag_id_ref() & { + return {value_.tag_id, type_, tag_id, this, ::apache::thrift::detail::union_field_ref_owner_vtable_for}; + } + + template + FOLLY_ERASE ::apache::thrift::union_field_ref tag_id_ref() && { + return {std::move(value_.tag_id), type_, tag_id, this, ::apache::thrift::detail::union_field_ref_owner_vtable_for}; + } + template + FOLLY_ERASE ::apache::thrift::union_field_ref edge_type_ref() const& { + return {value_.edge_type, type_, edge_type, this, ::apache::thrift::detail::union_field_ref_owner_vtable_for}; + } + + template + FOLLY_ERASE ::apache::thrift::union_field_ref edge_type_ref() const&& { + return {std::move(value_.edge_type), type_, edge_type, this, ::apache::thrift::detail::union_field_ref_owner_vtable_for}; + } + + template + FOLLY_ERASE ::apache::thrift::union_field_ref edge_type_ref() & { + return {value_.edge_type, type_, edge_type, this, ::apache::thrift::detail::union_field_ref_owner_vtable_for}; + } + + template + FOLLY_ERASE ::apache::thrift::union_field_ref edge_type_ref() && { + return {std::move(value_.edge_type), type_, edge_type, this, ::apache::thrift::detail::union_field_ref_owner_vtable_for}; + } + template + FOLLY_ERASE ::apache::thrift::union_field_ref index_id_ref() const& { + return {value_.index_id, type_, index_id, this, ::apache::thrift::detail::union_field_ref_owner_vtable_for}; + } + + template + FOLLY_ERASE ::apache::thrift::union_field_ref index_id_ref() const&& { + return {std::move(value_.index_id), type_, index_id, this, ::apache::thrift::detail::union_field_ref_owner_vtable_for}; + } + + template + FOLLY_ERASE ::apache::thrift::union_field_ref index_id_ref() & { + return {value_.index_id, type_, index_id, this, ::apache::thrift::detail::union_field_ref_owner_vtable_for}; + } + + template + FOLLY_ERASE ::apache::thrift::union_field_ref index_id_ref() && { + return {std::move(value_.index_id), type_, index_id, this, ::apache::thrift::detail::union_field_ref_owner_vtable_for}; + } + template + FOLLY_ERASE ::apache::thrift::union_field_ref cluster_id_ref() const& { + return {value_.cluster_id, type_, cluster_id, this, ::apache::thrift::detail::union_field_ref_owner_vtable_for}; + } + + template + FOLLY_ERASE ::apache::thrift::union_field_ref cluster_id_ref() const&& { + return {std::move(value_.cluster_id), type_, cluster_id, this, ::apache::thrift::detail::union_field_ref_owner_vtable_for}; + } + + template + FOLLY_ERASE ::apache::thrift::union_field_ref cluster_id_ref() & { + return {value_.cluster_id, type_, cluster_id, this, ::apache::thrift::detail::union_field_ref_owner_vtable_for}; + } + + template + FOLLY_ERASE ::apache::thrift::union_field_ref cluster_id_ref() && { + return {std::move(value_.cluster_id), type_, cluster_id, this, ::apache::thrift::detail::union_field_ref_owner_vtable_for}; + } + Type getType() const { return static_cast(type_); } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + protected: + template + void destruct(T &val) { + (&val)->~T(); + } + + storage_type value_; + std::underlying_type_t type_; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< ID >; + friend void swap(ID& a, ID& b); +}; + +template +uint32_t ID::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class ColumnTypeDef final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = ColumnTypeDef; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + ColumnTypeDef() : + type( ::nebula::meta::cpp2::PropertyType::UNKNOWN), + type_length(static_cast(0)), + geo_shape( ::nebula::meta::cpp2::GeoShape::ANY) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + ColumnTypeDef(apache::thrift::FragileConstructor, ::nebula::meta::cpp2::PropertyType type__arg, int16_t type_length__arg, ::nebula::meta::cpp2::GeoShape geo_shape__arg); + + ColumnTypeDef(ColumnTypeDef&&) = default; + + ColumnTypeDef(const ColumnTypeDef&) = default; + + + ColumnTypeDef& operator=(ColumnTypeDef&&) = default; + + ColumnTypeDef& operator=(const ColumnTypeDef&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + public: + ::nebula::meta::cpp2::PropertyType type; + private: + int16_t type_length; + private: + ::nebula::meta::cpp2::GeoShape geo_shape; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool type_length; + bool geo_shape; + } __isset = {}; + bool operator==(const ColumnTypeDef& rhs) const; +#ifndef SWIG + friend bool operator!=(const ColumnTypeDef& __x, const ColumnTypeDef& __y) { + return !(__x == __y); + } +#endif + bool operator<(const ColumnTypeDef& rhs) const; +#ifndef SWIG + friend bool operator>(const ColumnTypeDef& __x, const ColumnTypeDef& __y) { + return __y < __x; + } + friend bool operator<=(const ColumnTypeDef& __x, const ColumnTypeDef& __y) { + return !(__y < __x); + } + friend bool operator>=(const ColumnTypeDef& __x, const ColumnTypeDef& __y) { + return !(__x < __y); + } +#endif + template + FOLLY_ERASE ::apache::thrift::required_field_ref type_ref() const& { + return ::apache::thrift::required_field_ref{this->type}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref type_ref() const&& { + return ::apache::thrift::required_field_ref{std::move(this->type)}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref type_ref() & { + return ::apache::thrift::required_field_ref{this->type}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref type_ref() && { + return ::apache::thrift::required_field_ref{std::move(this->type)}; + } + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::optional_field_ref type_length_ref() const& { + return {this->type_length, __isset.type_length}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref type_length_ref() const&& { + return {std::move(this->type_length), __isset.type_length}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref type_length_ref() & { + return {this->type_length, __isset.type_length}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref type_length_ref() && { + return {std::move(this->type_length), __isset.type_length}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::optional_field_ref geo_shape_ref() const& { + return {this->geo_shape, __isset.geo_shape}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref geo_shape_ref() const&& { + return {std::move(this->geo_shape), __isset.geo_shape}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref geo_shape_ref() & { + return {this->geo_shape, __isset.geo_shape}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref geo_shape_ref() && { + return {std::move(this->geo_shape), __isset.geo_shape}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::meta::cpp2::PropertyType get_type() const { + return type; + } + + ::nebula::meta::cpp2::PropertyType& set_type( ::nebula::meta::cpp2::PropertyType type_) { + type = type_; + return type; + } + + const int16_t* get_type_length() const& { + return type_length_ref() ? std::addressof(type_length) : nullptr; + } + + int16_t* get_type_length() & { + return type_length_ref() ? std::addressof(type_length) : nullptr; + } + int16_t* get_type_length() && = delete; + + int16_t& set_type_length(int16_t type_length_) { + type_length = type_length_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.type_length = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return type_length; + } + + const ::nebula::meta::cpp2::GeoShape* get_geo_shape() const& { + return geo_shape_ref() ? std::addressof(geo_shape) : nullptr; + } + + ::nebula::meta::cpp2::GeoShape* get_geo_shape() & { + return geo_shape_ref() ? std::addressof(geo_shape) : nullptr; + } + ::nebula::meta::cpp2::GeoShape* get_geo_shape() && = delete; + + ::nebula::meta::cpp2::GeoShape& set_geo_shape( ::nebula::meta::cpp2::GeoShape geo_shape_) { + geo_shape = geo_shape_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.geo_shape = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return geo_shape; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< ColumnTypeDef >; + friend void swap(ColumnTypeDef& a, ColumnTypeDef& b); +}; + +template +uint32_t ColumnTypeDef::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class ColumnDef final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = ColumnDef; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + + ColumnDef(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + ColumnDef(apache::thrift::FragileConstructor, ::std::string name__arg, ::nebula::meta::cpp2::ColumnTypeDef type__arg, ::std::string default_value__arg, bool nullable__arg, ::std::string comment__arg); + + ColumnDef(ColumnDef&&) = default; + + ColumnDef(const ColumnDef&) = default; + + + ColumnDef& operator=(ColumnDef&&) = default; + + ColumnDef& operator=(const ColumnDef&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + + ~ColumnDef(); + + public: + ::std::string name; + public: + ::nebula::meta::cpp2::ColumnTypeDef type; + private: + ::std::string default_value; + private: + bool nullable; + private: + ::std::string comment; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool default_value; + bool nullable; + bool comment; + } __isset = {}; + bool operator==(const ColumnDef& rhs) const; +#ifndef SWIG + friend bool operator!=(const ColumnDef& __x, const ColumnDef& __y) { + return !(__x == __y); + } +#endif + bool operator<(const ColumnDef& rhs) const; +#ifndef SWIG + friend bool operator>(const ColumnDef& __x, const ColumnDef& __y) { + return __y < __x; + } + friend bool operator<=(const ColumnDef& __x, const ColumnDef& __y) { + return !(__y < __x); + } + friend bool operator>=(const ColumnDef& __x, const ColumnDef& __y) { + return !(__x < __y); + } +#endif + template + FOLLY_ERASE ::apache::thrift::required_field_ref name_ref() const& { + return ::apache::thrift::required_field_ref{this->name}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref name_ref() const&& { + return ::apache::thrift::required_field_ref{std::move(this->name)}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref name_ref() & { + return ::apache::thrift::required_field_ref{this->name}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref name_ref() && { + return ::apache::thrift::required_field_ref{std::move(this->name)}; + } + template + FOLLY_ERASE ::apache::thrift::required_field_ref type_ref() const& { + return ::apache::thrift::required_field_ref{this->type}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref type_ref() const&& { + return ::apache::thrift::required_field_ref{std::move(this->type)}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref type_ref() & { + return ::apache::thrift::required_field_ref{this->type}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref type_ref() && { + return ::apache::thrift::required_field_ref{std::move(this->type)}; + } + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::optional_field_ref default_value_ref() const& { + return {this->default_value, __isset.default_value}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref default_value_ref() const&& { + return {std::move(this->default_value), __isset.default_value}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref default_value_ref() & { + return {this->default_value, __isset.default_value}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref default_value_ref() && { + return {std::move(this->default_value), __isset.default_value}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::optional_field_ref nullable_ref() const& { + return {this->nullable, __isset.nullable}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref nullable_ref() const&& { + return {std::move(this->nullable), __isset.nullable}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref nullable_ref() & { + return {this->nullable, __isset.nullable}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref nullable_ref() && { + return {std::move(this->nullable), __isset.nullable}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::optional_field_ref comment_ref() const& { + return {this->comment, __isset.comment}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref comment_ref() const&& { + return {std::move(this->comment), __isset.comment}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref comment_ref() & { + return {this->comment, __isset.comment}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref comment_ref() && { + return {std::move(this->comment), __isset.comment}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + const ::std::string& get_name() const& { + return name; + } + + ::std::string get_name() && { + return std::move(name); + } + + template + ::std::string& set_name(T_ColumnDef_name_struct_setter&& name_) { + name = std::forward(name_); + return name; + } + const ::nebula::meta::cpp2::ColumnTypeDef& get_type() const&; + ::nebula::meta::cpp2::ColumnTypeDef get_type() &&; + + template + ::nebula::meta::cpp2::ColumnTypeDef& set_type(T_ColumnDef_type_struct_setter&& type_) { + type = std::forward(type_); + return type; + } + + const ::std::string* get_default_value() const& { + return default_value_ref() ? std::addressof(default_value) : nullptr; + } + + ::std::string* get_default_value() & { + return default_value_ref() ? std::addressof(default_value) : nullptr; + } + ::std::string* get_default_value() && = delete; + + template + ::std::string& set_default_value(T_ColumnDef_default_value_struct_setter&& default_value_) { + default_value = std::forward(default_value_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.default_value = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return default_value; + } + + const bool* get_nullable() const& { + return nullable_ref() ? std::addressof(nullable) : nullptr; + } + + bool* get_nullable() & { + return nullable_ref() ? std::addressof(nullable) : nullptr; + } + bool* get_nullable() && = delete; + + bool& set_nullable(bool nullable_) { + nullable = nullable_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.nullable = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return nullable; + } + + const ::std::string* get_comment() const& { + return comment_ref() ? std::addressof(comment) : nullptr; + } + + ::std::string* get_comment() & { + return comment_ref() ? std::addressof(comment) : nullptr; + } + ::std::string* get_comment() && = delete; + + template + ::std::string& set_comment(T_ColumnDef_comment_struct_setter&& comment_) { + comment = std::forward(comment_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.comment = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return comment; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< ColumnDef >; + friend void swap(ColumnDef& a, ColumnDef& b); +}; + +template +uint32_t ColumnDef::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class SchemaProp final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = SchemaProp; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + SchemaProp() : + ttl_duration(0) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + SchemaProp(apache::thrift::FragileConstructor, int64_t ttl_duration__arg, ::std::string ttl_col__arg, ::std::string comment__arg); + + SchemaProp(SchemaProp&&) = default; + + SchemaProp(const SchemaProp&) = default; + + + SchemaProp& operator=(SchemaProp&&) = default; + + SchemaProp& operator=(const SchemaProp&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + int64_t ttl_duration; + private: + ::std::string ttl_col; + private: + ::std::string comment; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool ttl_duration; + bool ttl_col; + bool comment; + } __isset = {}; + bool operator==(const SchemaProp& rhs) const; +#ifndef SWIG + friend bool operator!=(const SchemaProp& __x, const SchemaProp& __y) { + return !(__x == __y); + } +#endif + bool operator<(const SchemaProp& rhs) const; +#ifndef SWIG + friend bool operator>(const SchemaProp& __x, const SchemaProp& __y) { + return __y < __x; + } + friend bool operator<=(const SchemaProp& __x, const SchemaProp& __y) { + return !(__y < __x); + } + friend bool operator>=(const SchemaProp& __x, const SchemaProp& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::optional_field_ref ttl_duration_ref() const& { + return {this->ttl_duration, __isset.ttl_duration}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref ttl_duration_ref() const&& { + return {std::move(this->ttl_duration), __isset.ttl_duration}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref ttl_duration_ref() & { + return {this->ttl_duration, __isset.ttl_duration}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref ttl_duration_ref() && { + return {std::move(this->ttl_duration), __isset.ttl_duration}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::optional_field_ref ttl_col_ref() const& { + return {this->ttl_col, __isset.ttl_col}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref ttl_col_ref() const&& { + return {std::move(this->ttl_col), __isset.ttl_col}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref ttl_col_ref() & { + return {this->ttl_col, __isset.ttl_col}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref ttl_col_ref() && { + return {std::move(this->ttl_col), __isset.ttl_col}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::optional_field_ref comment_ref() const& { + return {this->comment, __isset.comment}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref comment_ref() const&& { + return {std::move(this->comment), __isset.comment}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref comment_ref() & { + return {this->comment, __isset.comment}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref comment_ref() && { + return {std::move(this->comment), __isset.comment}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + const int64_t* get_ttl_duration() const& { + return ttl_duration_ref() ? std::addressof(ttl_duration) : nullptr; + } + + int64_t* get_ttl_duration() & { + return ttl_duration_ref() ? std::addressof(ttl_duration) : nullptr; + } + int64_t* get_ttl_duration() && = delete; + + int64_t& set_ttl_duration(int64_t ttl_duration_) { + ttl_duration = ttl_duration_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.ttl_duration = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return ttl_duration; + } + + const ::std::string* get_ttl_col() const& { + return ttl_col_ref() ? std::addressof(ttl_col) : nullptr; + } + + ::std::string* get_ttl_col() & { + return ttl_col_ref() ? std::addressof(ttl_col) : nullptr; + } + ::std::string* get_ttl_col() && = delete; + + template + ::std::string& set_ttl_col(T_SchemaProp_ttl_col_struct_setter&& ttl_col_) { + ttl_col = std::forward(ttl_col_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.ttl_col = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return ttl_col; + } + + const ::std::string* get_comment() const& { + return comment_ref() ? std::addressof(comment) : nullptr; + } + + ::std::string* get_comment() & { + return comment_ref() ? std::addressof(comment) : nullptr; + } + ::std::string* get_comment() && = delete; + + template + ::std::string& set_comment(T_SchemaProp_comment_struct_setter&& comment_) { + comment = std::forward(comment_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.comment = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return comment; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< SchemaProp >; + friend void swap(SchemaProp& a, SchemaProp& b); +}; + +template +uint32_t SchemaProp::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class Schema final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = Schema; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + Schema() {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + Schema(apache::thrift::FragileConstructor, ::std::vector< ::nebula::meta::cpp2::ColumnDef> columns__arg, ::nebula::meta::cpp2::SchemaProp schema_prop__arg); + + Schema(Schema&&) = default; + + Schema(const Schema&) = default; + + + Schema& operator=(Schema&&) = default; + + Schema& operator=(const Schema&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::std::vector< ::nebula::meta::cpp2::ColumnDef> columns; + private: + ::nebula::meta::cpp2::SchemaProp schema_prop; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool columns; + bool schema_prop; + } __isset = {}; + bool operator==(const Schema& rhs) const; +#ifndef SWIG + friend bool operator!=(const Schema& __x, const Schema& __y) { + return !(__x == __y); + } +#endif + bool operator<(const Schema& rhs) const; +#ifndef SWIG + friend bool operator>(const Schema& __x, const Schema& __y) { + return __y < __x; + } + friend bool operator<=(const Schema& __x, const Schema& __y) { + return !(__y < __x); + } + friend bool operator>=(const Schema& __x, const Schema& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::field_ref columns_ref() const& { + return {this->columns, __isset.columns}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref columns_ref() const&& { + return {std::move(this->columns), __isset.columns}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref columns_ref() & { + return {this->columns, __isset.columns}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref columns_ref() && { + return {std::move(this->columns), __isset.columns}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref schema_prop_ref() const& { + return {this->schema_prop, __isset.schema_prop}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref schema_prop_ref() const&& { + return {std::move(this->schema_prop), __isset.schema_prop}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref schema_prop_ref() & { + return {this->schema_prop, __isset.schema_prop}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref schema_prop_ref() && { + return {std::move(this->schema_prop), __isset.schema_prop}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + const ::std::vector< ::nebula::meta::cpp2::ColumnDef>& get_columns() const&; + ::std::vector< ::nebula::meta::cpp2::ColumnDef> get_columns() &&; + + template > + ::std::vector< ::nebula::meta::cpp2::ColumnDef>& set_columns(T_Schema_columns_struct_setter&& columns_) { + columns = std::forward(columns_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.columns = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return columns; + } + const ::nebula::meta::cpp2::SchemaProp& get_schema_prop() const&; + ::nebula::meta::cpp2::SchemaProp get_schema_prop() &&; + + template + ::nebula::meta::cpp2::SchemaProp& set_schema_prop(T_Schema_schema_prop_struct_setter&& schema_prop_) { + schema_prop = std::forward(schema_prop_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.schema_prop = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return schema_prop; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< Schema >; + friend void swap(Schema& a, Schema& b); +}; + +template +uint32_t Schema::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class IdName final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = IdName; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + IdName() {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + IdName(apache::thrift::FragileConstructor, ::nebula::meta::cpp2::ID id__arg, ::std::string name__arg); + + IdName(IdName&&) = default; + + IdName(const IdName&) = default; + + + IdName& operator=(IdName&&) = default; + + IdName& operator=(const IdName&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::meta::cpp2::ID id; + private: + ::std::string name; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool id; + bool name; + } __isset = {}; + bool operator==(const IdName& rhs) const; +#ifndef SWIG + friend bool operator!=(const IdName& __x, const IdName& __y) { + return !(__x == __y); + } +#endif + bool operator<(const IdName& rhs) const; +#ifndef SWIG + friend bool operator>(const IdName& __x, const IdName& __y) { + return __y < __x; + } + friend bool operator<=(const IdName& __x, const IdName& __y) { + return !(__y < __x); + } + friend bool operator>=(const IdName& __x, const IdName& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref id_ref() const& { + return {this->id, __isset.id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref id_ref() const&& { + return {std::move(this->id), __isset.id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref id_ref() & { + return {this->id, __isset.id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref id_ref() && { + return {std::move(this->id), __isset.id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref name_ref() const& { + return {this->name, __isset.name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref name_ref() const&& { + return {std::move(this->name), __isset.name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref name_ref() & { + return {this->name, __isset.name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref name_ref() && { + return {std::move(this->name), __isset.name}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + const ::nebula::meta::cpp2::ID& get_id() const&; + ::nebula::meta::cpp2::ID get_id() &&; + + template + ::nebula::meta::cpp2::ID& set_id(T_IdName_id_struct_setter&& id_) { + id = std::forward(id_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return id; + } + + const ::std::string& get_name() const& { + return name; + } + + ::std::string get_name() && { + return std::move(name); + } + + template + ::std::string& set_name(T_IdName_name_struct_setter&& name_) { + name = std::forward(name_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.name = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return name; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< IdName >; + friend void swap(IdName& a, IdName& b); +}; + +template +uint32_t IdName::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class SpaceDesc final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = SpaceDesc; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + + SpaceDesc(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + SpaceDesc(apache::thrift::FragileConstructor, ::std::string space_name__arg, int32_t partition_num__arg, int32_t replica_factor__arg, ::std::string charset_name__arg, ::std::string collate_name__arg, ::nebula::meta::cpp2::ColumnTypeDef vid_type__arg, ::std::string group_name__arg, ::nebula::meta::cpp2::IsolationLevel isolation_level__arg, ::std::string comment__arg); + + SpaceDesc(SpaceDesc&&) = default; + + SpaceDesc(const SpaceDesc&) = default; + + + SpaceDesc& operator=(SpaceDesc&&) = default; + + SpaceDesc& operator=(const SpaceDesc&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + + ~SpaceDesc(); + + private: + ::std::string space_name; + private: + int32_t partition_num; + private: + int32_t replica_factor; + private: + ::std::string charset_name; + private: + ::std::string collate_name; + private: + ::nebula::meta::cpp2::ColumnTypeDef vid_type; + private: + ::std::string group_name; + private: + ::nebula::meta::cpp2::IsolationLevel isolation_level; + private: + ::std::string comment; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool space_name; + bool partition_num; + bool replica_factor; + bool charset_name; + bool collate_name; + bool vid_type; + bool group_name; + bool isolation_level; + bool comment; + } __isset = {}; + bool operator==(const SpaceDesc& rhs) const; +#ifndef SWIG + friend bool operator!=(const SpaceDesc& __x, const SpaceDesc& __y) { + return !(__x == __y); + } +#endif + bool operator<(const SpaceDesc& rhs) const; +#ifndef SWIG + friend bool operator>(const SpaceDesc& __x, const SpaceDesc& __y) { + return __y < __x; + } + friend bool operator<=(const SpaceDesc& __x, const SpaceDesc& __y) { + return !(__y < __x); + } + friend bool operator>=(const SpaceDesc& __x, const SpaceDesc& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref space_name_ref() const& { + return {this->space_name, __isset.space_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_name_ref() const&& { + return {std::move(this->space_name), __isset.space_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_name_ref() & { + return {this->space_name, __isset.space_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_name_ref() && { + return {std::move(this->space_name), __isset.space_name}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref partition_num_ref() const& { + return {this->partition_num, __isset.partition_num}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref partition_num_ref() const&& { + return {std::move(this->partition_num), __isset.partition_num}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref partition_num_ref() & { + return {this->partition_num, __isset.partition_num}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref partition_num_ref() && { + return {std::move(this->partition_num), __isset.partition_num}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref replica_factor_ref() const& { + return {this->replica_factor, __isset.replica_factor}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref replica_factor_ref() const&& { + return {std::move(this->replica_factor), __isset.replica_factor}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref replica_factor_ref() & { + return {this->replica_factor, __isset.replica_factor}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref replica_factor_ref() && { + return {std::move(this->replica_factor), __isset.replica_factor}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref charset_name_ref() const& { + return {this->charset_name, __isset.charset_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref charset_name_ref() const&& { + return {std::move(this->charset_name), __isset.charset_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref charset_name_ref() & { + return {this->charset_name, __isset.charset_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref charset_name_ref() && { + return {std::move(this->charset_name), __isset.charset_name}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref collate_name_ref() const& { + return {this->collate_name, __isset.collate_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref collate_name_ref() const&& { + return {std::move(this->collate_name), __isset.collate_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref collate_name_ref() & { + return {this->collate_name, __isset.collate_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref collate_name_ref() && { + return {std::move(this->collate_name), __isset.collate_name}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref vid_type_ref() const& { + return {this->vid_type, __isset.vid_type}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref vid_type_ref() const&& { + return {std::move(this->vid_type), __isset.vid_type}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref vid_type_ref() & { + return {this->vid_type, __isset.vid_type}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref vid_type_ref() && { + return {std::move(this->vid_type), __isset.vid_type}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::optional_field_ref group_name_ref() const& { + return {this->group_name, __isset.group_name}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref group_name_ref() const&& { + return {std::move(this->group_name), __isset.group_name}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref group_name_ref() & { + return {this->group_name, __isset.group_name}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref group_name_ref() && { + return {std::move(this->group_name), __isset.group_name}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::optional_field_ref isolation_level_ref() const& { + return {this->isolation_level, __isset.isolation_level}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref isolation_level_ref() const&& { + return {std::move(this->isolation_level), __isset.isolation_level}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref isolation_level_ref() & { + return {this->isolation_level, __isset.isolation_level}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref isolation_level_ref() && { + return {std::move(this->isolation_level), __isset.isolation_level}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::optional_field_ref comment_ref() const& { + return {this->comment, __isset.comment}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref comment_ref() const&& { + return {std::move(this->comment), __isset.comment}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref comment_ref() & { + return {this->comment, __isset.comment}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref comment_ref() && { + return {std::move(this->comment), __isset.comment}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + const ::std::string& get_space_name() const& { + return space_name; + } + + ::std::string get_space_name() && { + return std::move(space_name); + } + + template + ::std::string& set_space_name(T_SpaceDesc_space_name_struct_setter&& space_name_) { + space_name = std::forward(space_name_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.space_name = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return space_name; + } + + int32_t get_partition_num() const { + return partition_num; + } + + int32_t& set_partition_num(int32_t partition_num_) { + partition_num = partition_num_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.partition_num = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return partition_num; + } + + int32_t get_replica_factor() const { + return replica_factor; + } + + int32_t& set_replica_factor(int32_t replica_factor_) { + replica_factor = replica_factor_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.replica_factor = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return replica_factor; + } + + const ::std::string& get_charset_name() const& { + return charset_name; + } + + ::std::string get_charset_name() && { + return std::move(charset_name); + } + + template + ::std::string& set_charset_name(T_SpaceDesc_charset_name_struct_setter&& charset_name_) { + charset_name = std::forward(charset_name_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.charset_name = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return charset_name; + } + + const ::std::string& get_collate_name() const& { + return collate_name; + } + + ::std::string get_collate_name() && { + return std::move(collate_name); + } + + template + ::std::string& set_collate_name(T_SpaceDesc_collate_name_struct_setter&& collate_name_) { + collate_name = std::forward(collate_name_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.collate_name = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return collate_name; + } + const ::nebula::meta::cpp2::ColumnTypeDef& get_vid_type() const&; + ::nebula::meta::cpp2::ColumnTypeDef get_vid_type() &&; + + template + ::nebula::meta::cpp2::ColumnTypeDef& set_vid_type(T_SpaceDesc_vid_type_struct_setter&& vid_type_) { + vid_type = std::forward(vid_type_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.vid_type = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return vid_type; + } + + const ::std::string* get_group_name() const& { + return group_name_ref() ? std::addressof(group_name) : nullptr; + } + + ::std::string* get_group_name() & { + return group_name_ref() ? std::addressof(group_name) : nullptr; + } + ::std::string* get_group_name() && = delete; + + template + ::std::string& set_group_name(T_SpaceDesc_group_name_struct_setter&& group_name_) { + group_name = std::forward(group_name_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.group_name = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return group_name; + } + + const ::nebula::meta::cpp2::IsolationLevel* get_isolation_level() const& { + return isolation_level_ref() ? std::addressof(isolation_level) : nullptr; + } + + ::nebula::meta::cpp2::IsolationLevel* get_isolation_level() & { + return isolation_level_ref() ? std::addressof(isolation_level) : nullptr; + } + ::nebula::meta::cpp2::IsolationLevel* get_isolation_level() && = delete; + + ::nebula::meta::cpp2::IsolationLevel& set_isolation_level( ::nebula::meta::cpp2::IsolationLevel isolation_level_) { + isolation_level = isolation_level_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.isolation_level = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return isolation_level; + } + + const ::std::string* get_comment() const& { + return comment_ref() ? std::addressof(comment) : nullptr; + } + + ::std::string* get_comment() & { + return comment_ref() ? std::addressof(comment) : nullptr; + } + ::std::string* get_comment() && = delete; + + template + ::std::string& set_comment(T_SpaceDesc_comment_struct_setter&& comment_) { + comment = std::forward(comment_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.comment = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return comment; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< SpaceDesc >; + friend void swap(SpaceDesc& a, SpaceDesc& b); +}; + +template +uint32_t SpaceDesc::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class SpaceItem final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = SpaceItem; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + SpaceItem() : + space_id(0) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + SpaceItem(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, ::nebula::meta::cpp2::SpaceDesc properties__arg); + + SpaceItem(SpaceItem&&) = default; + + SpaceItem(const SpaceItem&) = default; + + + SpaceItem& operator=(SpaceItem&&) = default; + + SpaceItem& operator=(const SpaceItem&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::GraphSpaceID space_id; + private: + ::nebula::meta::cpp2::SpaceDesc properties; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool space_id; + bool properties; + } __isset = {}; + bool operator==(const SpaceItem& rhs) const; +#ifndef SWIG + friend bool operator!=(const SpaceItem& __x, const SpaceItem& __y) { + return !(__x == __y); + } +#endif + bool operator<(const SpaceItem& rhs) const; +#ifndef SWIG + friend bool operator>(const SpaceItem& __x, const SpaceItem& __y) { + return __y < __x; + } + friend bool operator<=(const SpaceItem& __x, const SpaceItem& __y) { + return !(__y < __x); + } + friend bool operator>=(const SpaceItem& __x, const SpaceItem& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const& { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const&& { + return {std::move(this->space_id), __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() & { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() && { + return {std::move(this->space_id), __isset.space_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref properties_ref() const& { + return {this->properties, __isset.properties}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref properties_ref() const&& { + return {std::move(this->properties), __isset.properties}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref properties_ref() & { + return {this->properties, __isset.properties}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref properties_ref() && { + return {std::move(this->properties), __isset.properties}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::GraphSpaceID get_space_id() const { + return space_id; + } + + ::nebula::cpp2::GraphSpaceID& set_space_id( ::nebula::cpp2::GraphSpaceID space_id_) { + space_id = space_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.space_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return space_id; + } + const ::nebula::meta::cpp2::SpaceDesc& get_properties() const&; + ::nebula::meta::cpp2::SpaceDesc get_properties() &&; + + template + ::nebula::meta::cpp2::SpaceDesc& set_properties(T_SpaceItem_properties_struct_setter&& properties_) { + properties = std::forward(properties_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.properties = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return properties; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< SpaceItem >; + friend void swap(SpaceItem& a, SpaceItem& b); +}; + +template +uint32_t SpaceItem::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class TagItem final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = TagItem; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + TagItem() : + tag_id(0), + version(0) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + TagItem(apache::thrift::FragileConstructor, ::nebula::cpp2::TagID tag_id__arg, ::std::string tag_name__arg, ::nebula::meta::cpp2::SchemaVer version__arg, ::nebula::meta::cpp2::Schema schema__arg); + + TagItem(TagItem&&) = default; + + TagItem(const TagItem&) = default; + + + TagItem& operator=(TagItem&&) = default; + + TagItem& operator=(const TagItem&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::TagID tag_id; + private: + ::std::string tag_name; + private: + ::nebula::meta::cpp2::SchemaVer version; + private: + ::nebula::meta::cpp2::Schema schema; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool tag_id; + bool tag_name; + bool version; + bool schema; + } __isset = {}; + bool operator==(const TagItem& rhs) const; +#ifndef SWIG + friend bool operator!=(const TagItem& __x, const TagItem& __y) { + return !(__x == __y); + } +#endif + bool operator<(const TagItem& rhs) const; +#ifndef SWIG + friend bool operator>(const TagItem& __x, const TagItem& __y) { + return __y < __x; + } + friend bool operator<=(const TagItem& __x, const TagItem& __y) { + return !(__y < __x); + } + friend bool operator>=(const TagItem& __x, const TagItem& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref tag_id_ref() const& { + return {this->tag_id, __isset.tag_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref tag_id_ref() const&& { + return {std::move(this->tag_id), __isset.tag_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref tag_id_ref() & { + return {this->tag_id, __isset.tag_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref tag_id_ref() && { + return {std::move(this->tag_id), __isset.tag_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref tag_name_ref() const& { + return {this->tag_name, __isset.tag_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref tag_name_ref() const&& { + return {std::move(this->tag_name), __isset.tag_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref tag_name_ref() & { + return {this->tag_name, __isset.tag_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref tag_name_ref() && { + return {std::move(this->tag_name), __isset.tag_name}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref version_ref() const& { + return {this->version, __isset.version}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref version_ref() const&& { + return {std::move(this->version), __isset.version}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref version_ref() & { + return {this->version, __isset.version}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref version_ref() && { + return {std::move(this->version), __isset.version}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref schema_ref() const& { + return {this->schema, __isset.schema}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref schema_ref() const&& { + return {std::move(this->schema), __isset.schema}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref schema_ref() & { + return {this->schema, __isset.schema}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref schema_ref() && { + return {std::move(this->schema), __isset.schema}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::TagID get_tag_id() const { + return tag_id; + } + + ::nebula::cpp2::TagID& set_tag_id( ::nebula::cpp2::TagID tag_id_) { + tag_id = tag_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.tag_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return tag_id; + } + + const ::std::string& get_tag_name() const& { + return tag_name; + } + + ::std::string get_tag_name() && { + return std::move(tag_name); + } + + template + ::std::string& set_tag_name(T_TagItem_tag_name_struct_setter&& tag_name_) { + tag_name = std::forward(tag_name_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.tag_name = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return tag_name; + } + + ::nebula::meta::cpp2::SchemaVer get_version() const { + return version; + } + + ::nebula::meta::cpp2::SchemaVer& set_version( ::nebula::meta::cpp2::SchemaVer version_) { + version = version_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.version = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return version; + } + const ::nebula::meta::cpp2::Schema& get_schema() const&; + ::nebula::meta::cpp2::Schema get_schema() &&; + + template + ::nebula::meta::cpp2::Schema& set_schema(T_TagItem_schema_struct_setter&& schema_) { + schema = std::forward(schema_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.schema = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return schema; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< TagItem >; + friend void swap(TagItem& a, TagItem& b); +}; + +template +uint32_t TagItem::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class AlterSchemaItem final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = AlterSchemaItem; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + AlterSchemaItem() : + op(static_cast< ::nebula::meta::cpp2::AlterSchemaOp>(0)) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + AlterSchemaItem(apache::thrift::FragileConstructor, ::nebula::meta::cpp2::AlterSchemaOp op__arg, ::nebula::meta::cpp2::Schema schema__arg); + + AlterSchemaItem(AlterSchemaItem&&) = default; + + AlterSchemaItem(const AlterSchemaItem&) = default; + + + AlterSchemaItem& operator=(AlterSchemaItem&&) = default; + + AlterSchemaItem& operator=(const AlterSchemaItem&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::meta::cpp2::AlterSchemaOp op; + private: + ::nebula::meta::cpp2::Schema schema; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool op; + bool schema; + } __isset = {}; + bool operator==(const AlterSchemaItem& rhs) const; +#ifndef SWIG + friend bool operator!=(const AlterSchemaItem& __x, const AlterSchemaItem& __y) { + return !(__x == __y); + } +#endif + bool operator<(const AlterSchemaItem& rhs) const; +#ifndef SWIG + friend bool operator>(const AlterSchemaItem& __x, const AlterSchemaItem& __y) { + return __y < __x; + } + friend bool operator<=(const AlterSchemaItem& __x, const AlterSchemaItem& __y) { + return !(__y < __x); + } + friend bool operator>=(const AlterSchemaItem& __x, const AlterSchemaItem& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref op_ref() const& { + return {this->op, __isset.op}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref op_ref() const&& { + return {std::move(this->op), __isset.op}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref op_ref() & { + return {this->op, __isset.op}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref op_ref() && { + return {std::move(this->op), __isset.op}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref schema_ref() const& { + return {this->schema, __isset.schema}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref schema_ref() const&& { + return {std::move(this->schema), __isset.schema}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref schema_ref() & { + return {this->schema, __isset.schema}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref schema_ref() && { + return {std::move(this->schema), __isset.schema}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::meta::cpp2::AlterSchemaOp get_op() const { + return op; + } + + ::nebula::meta::cpp2::AlterSchemaOp& set_op( ::nebula::meta::cpp2::AlterSchemaOp op_) { + op = op_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.op = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return op; + } + const ::nebula::meta::cpp2::Schema& get_schema() const&; + ::nebula::meta::cpp2::Schema get_schema() &&; + + template + ::nebula::meta::cpp2::Schema& set_schema(T_AlterSchemaItem_schema_struct_setter&& schema_) { + schema = std::forward(schema_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.schema = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return schema; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< AlterSchemaItem >; + friend void swap(AlterSchemaItem& a, AlterSchemaItem& b); +}; + +template +uint32_t AlterSchemaItem::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class EdgeItem final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = EdgeItem; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + EdgeItem() : + edge_type(0), + version(0) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + EdgeItem(apache::thrift::FragileConstructor, ::nebula::cpp2::EdgeType edge_type__arg, ::std::string edge_name__arg, ::nebula::meta::cpp2::SchemaVer version__arg, ::nebula::meta::cpp2::Schema schema__arg); + + EdgeItem(EdgeItem&&) = default; + + EdgeItem(const EdgeItem&) = default; + + + EdgeItem& operator=(EdgeItem&&) = default; + + EdgeItem& operator=(const EdgeItem&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::EdgeType edge_type; + private: + ::std::string edge_name; + private: + ::nebula::meta::cpp2::SchemaVer version; + private: + ::nebula::meta::cpp2::Schema schema; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool edge_type; + bool edge_name; + bool version; + bool schema; + } __isset = {}; + bool operator==(const EdgeItem& rhs) const; +#ifndef SWIG + friend bool operator!=(const EdgeItem& __x, const EdgeItem& __y) { + return !(__x == __y); + } +#endif + bool operator<(const EdgeItem& rhs) const; +#ifndef SWIG + friend bool operator>(const EdgeItem& __x, const EdgeItem& __y) { + return __y < __x; + } + friend bool operator<=(const EdgeItem& __x, const EdgeItem& __y) { + return !(__y < __x); + } + friend bool operator>=(const EdgeItem& __x, const EdgeItem& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref edge_type_ref() const& { + return {this->edge_type, __isset.edge_type}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref edge_type_ref() const&& { + return {std::move(this->edge_type), __isset.edge_type}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref edge_type_ref() & { + return {this->edge_type, __isset.edge_type}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref edge_type_ref() && { + return {std::move(this->edge_type), __isset.edge_type}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref edge_name_ref() const& { + return {this->edge_name, __isset.edge_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref edge_name_ref() const&& { + return {std::move(this->edge_name), __isset.edge_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref edge_name_ref() & { + return {this->edge_name, __isset.edge_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref edge_name_ref() && { + return {std::move(this->edge_name), __isset.edge_name}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref version_ref() const& { + return {this->version, __isset.version}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref version_ref() const&& { + return {std::move(this->version), __isset.version}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref version_ref() & { + return {this->version, __isset.version}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref version_ref() && { + return {std::move(this->version), __isset.version}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref schema_ref() const& { + return {this->schema, __isset.schema}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref schema_ref() const&& { + return {std::move(this->schema), __isset.schema}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref schema_ref() & { + return {this->schema, __isset.schema}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref schema_ref() && { + return {std::move(this->schema), __isset.schema}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::EdgeType get_edge_type() const { + return edge_type; + } + + ::nebula::cpp2::EdgeType& set_edge_type( ::nebula::cpp2::EdgeType edge_type_) { + edge_type = edge_type_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.edge_type = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return edge_type; + } + + const ::std::string& get_edge_name() const& { + return edge_name; + } + + ::std::string get_edge_name() && { + return std::move(edge_name); + } + + template + ::std::string& set_edge_name(T_EdgeItem_edge_name_struct_setter&& edge_name_) { + edge_name = std::forward(edge_name_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.edge_name = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return edge_name; + } + + ::nebula::meta::cpp2::SchemaVer get_version() const { + return version; + } + + ::nebula::meta::cpp2::SchemaVer& set_version( ::nebula::meta::cpp2::SchemaVer version_) { + version = version_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.version = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return version; + } + const ::nebula::meta::cpp2::Schema& get_schema() const&; + ::nebula::meta::cpp2::Schema get_schema() &&; + + template + ::nebula::meta::cpp2::Schema& set_schema(T_EdgeItem_schema_struct_setter&& schema_) { + schema = std::forward(schema_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.schema = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return schema; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< EdgeItem >; + friend void swap(EdgeItem& a, EdgeItem& b); +}; + +template +uint32_t EdgeItem::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class IndexItem final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = IndexItem; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + + IndexItem(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + IndexItem(apache::thrift::FragileConstructor, ::nebula::cpp2::IndexID index_id__arg, ::std::string index_name__arg, ::nebula::cpp2::SchemaID schema_id__arg, ::std::string schema_name__arg, ::std::vector< ::nebula::meta::cpp2::ColumnDef> fields__arg, ::std::string comment__arg); + + IndexItem(IndexItem&&) = default; + + IndexItem(const IndexItem&) = default; + + + IndexItem& operator=(IndexItem&&) = default; + + IndexItem& operator=(const IndexItem&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + + ~IndexItem(); + + private: + ::nebula::cpp2::IndexID index_id; + private: + ::std::string index_name; + private: + ::nebula::cpp2::SchemaID schema_id; + private: + ::std::string schema_name; + private: + ::std::vector< ::nebula::meta::cpp2::ColumnDef> fields; + private: + ::std::string comment; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool index_id; + bool index_name; + bool schema_id; + bool schema_name; + bool fields; + bool comment; + } __isset = {}; + bool operator==(const IndexItem& rhs) const; +#ifndef SWIG + friend bool operator!=(const IndexItem& __x, const IndexItem& __y) { + return !(__x == __y); + } +#endif + bool operator<(const IndexItem& rhs) const; +#ifndef SWIG + friend bool operator>(const IndexItem& __x, const IndexItem& __y) { + return __y < __x; + } + friend bool operator<=(const IndexItem& __x, const IndexItem& __y) { + return !(__y < __x); + } + friend bool operator>=(const IndexItem& __x, const IndexItem& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref index_id_ref() const& { + return {this->index_id, __isset.index_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref index_id_ref() const&& { + return {std::move(this->index_id), __isset.index_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref index_id_ref() & { + return {this->index_id, __isset.index_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref index_id_ref() && { + return {std::move(this->index_id), __isset.index_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref index_name_ref() const& { + return {this->index_name, __isset.index_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref index_name_ref() const&& { + return {std::move(this->index_name), __isset.index_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref index_name_ref() & { + return {this->index_name, __isset.index_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref index_name_ref() && { + return {std::move(this->index_name), __isset.index_name}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref schema_id_ref() const& { + return {this->schema_id, __isset.schema_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref schema_id_ref() const&& { + return {std::move(this->schema_id), __isset.schema_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref schema_id_ref() & { + return {this->schema_id, __isset.schema_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref schema_id_ref() && { + return {std::move(this->schema_id), __isset.schema_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref schema_name_ref() const& { + return {this->schema_name, __isset.schema_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref schema_name_ref() const&& { + return {std::move(this->schema_name), __isset.schema_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref schema_name_ref() & { + return {this->schema_name, __isset.schema_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref schema_name_ref() && { + return {std::move(this->schema_name), __isset.schema_name}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::field_ref fields_ref() const& { + return {this->fields, __isset.fields}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref fields_ref() const&& { + return {std::move(this->fields), __isset.fields}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref fields_ref() & { + return {this->fields, __isset.fields}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref fields_ref() && { + return {std::move(this->fields), __isset.fields}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::optional_field_ref comment_ref() const& { + return {this->comment, __isset.comment}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref comment_ref() const&& { + return {std::move(this->comment), __isset.comment}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref comment_ref() & { + return {this->comment, __isset.comment}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref comment_ref() && { + return {std::move(this->comment), __isset.comment}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::IndexID get_index_id() const { + return index_id; + } + + ::nebula::cpp2::IndexID& set_index_id( ::nebula::cpp2::IndexID index_id_) { + index_id = index_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.index_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return index_id; + } + + const ::std::string& get_index_name() const& { + return index_name; + } + + ::std::string get_index_name() && { + return std::move(index_name); + } + + template + ::std::string& set_index_name(T_IndexItem_index_name_struct_setter&& index_name_) { + index_name = std::forward(index_name_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.index_name = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return index_name; + } + const ::nebula::cpp2::SchemaID& get_schema_id() const&; + ::nebula::cpp2::SchemaID get_schema_id() &&; + + template + ::nebula::cpp2::SchemaID& set_schema_id(T_IndexItem_schema_id_struct_setter&& schema_id_) { + schema_id = std::forward(schema_id_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.schema_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return schema_id; + } + + const ::std::string& get_schema_name() const& { + return schema_name; + } + + ::std::string get_schema_name() && { + return std::move(schema_name); + } + + template + ::std::string& set_schema_name(T_IndexItem_schema_name_struct_setter&& schema_name_) { + schema_name = std::forward(schema_name_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.schema_name = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return schema_name; + } + const ::std::vector< ::nebula::meta::cpp2::ColumnDef>& get_fields() const&; + ::std::vector< ::nebula::meta::cpp2::ColumnDef> get_fields() &&; + + template > + ::std::vector< ::nebula::meta::cpp2::ColumnDef>& set_fields(T_IndexItem_fields_struct_setter&& fields_) { + fields = std::forward(fields_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.fields = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return fields; + } + + const ::std::string* get_comment() const& { + return comment_ref() ? std::addressof(comment) : nullptr; + } + + ::std::string* get_comment() & { + return comment_ref() ? std::addressof(comment) : nullptr; + } + ::std::string* get_comment() && = delete; + + template + ::std::string& set_comment(T_IndexItem_comment_struct_setter&& comment_) { + comment = std::forward(comment_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.comment = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return comment; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< IndexItem >; + friend void swap(IndexItem& a, IndexItem& b); +}; + +template +uint32_t IndexItem::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class HostItem final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = HostItem; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + + HostItem(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + HostItem(apache::thrift::FragileConstructor, nebula::HostAddr hostAddr__arg, ::nebula::meta::cpp2::HostStatus status__arg, std::unordered_map<::std::string, ::std::vector< ::nebula::cpp2::PartitionID>> leader_parts__arg, std::unordered_map<::std::string, ::std::vector< ::nebula::cpp2::PartitionID>> all_parts__arg, ::nebula::meta::cpp2::HostRole role__arg, ::std::string git_info_sha__arg, ::std::string zone_name__arg, ::std::string version__arg); + + HostItem(HostItem&&) = default; + + HostItem(const HostItem&) = default; + + + HostItem& operator=(HostItem&&) = default; + + HostItem& operator=(const HostItem&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + + ~HostItem(); + + private: + nebula::HostAddr hostAddr; + private: + ::nebula::meta::cpp2::HostStatus status; + private: + std::unordered_map<::std::string, ::std::vector< ::nebula::cpp2::PartitionID>> leader_parts; + private: + std::unordered_map<::std::string, ::std::vector< ::nebula::cpp2::PartitionID>> all_parts; + private: + ::nebula::meta::cpp2::HostRole role; + private: + ::std::string git_info_sha; + private: + ::std::string zone_name; + private: + ::std::string version; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool hostAddr; + bool status; + bool leader_parts; + bool all_parts; + bool role; + bool git_info_sha; + bool zone_name; + bool version; + } __isset = {}; + bool operator==(const HostItem& rhs) const; +#ifndef SWIG + friend bool operator!=(const HostItem& __x, const HostItem& __y) { + return !(__x == __y); + } +#endif + bool operator<(const HostItem& rhs) const; +#ifndef SWIG + friend bool operator>(const HostItem& __x, const HostItem& __y) { + return __y < __x; + } + friend bool operator<=(const HostItem& __x, const HostItem& __y) { + return !(__y < __x); + } + friend bool operator>=(const HostItem& __x, const HostItem& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref hostAddr_ref() const& { + return {this->hostAddr, __isset.hostAddr}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref hostAddr_ref() const&& { + return {std::move(this->hostAddr), __isset.hostAddr}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref hostAddr_ref() & { + return {this->hostAddr, __isset.hostAddr}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref hostAddr_ref() && { + return {std::move(this->hostAddr), __isset.hostAddr}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref status_ref() const& { + return {this->status, __isset.status}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref status_ref() const&& { + return {std::move(this->status), __isset.status}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref status_ref() & { + return {this->status, __isset.status}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref status_ref() && { + return {std::move(this->status), __isset.status}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template >> + FOLLY_ERASE ::apache::thrift::field_ref leader_parts_ref() const& { + return {this->leader_parts, __isset.leader_parts}; + } + + template >> + FOLLY_ERASE ::apache::thrift::field_ref leader_parts_ref() const&& { + return {std::move(this->leader_parts), __isset.leader_parts}; + } + + template >> + FOLLY_ERASE ::apache::thrift::field_ref leader_parts_ref() & { + return {this->leader_parts, __isset.leader_parts}; + } + + template >> + FOLLY_ERASE ::apache::thrift::field_ref leader_parts_ref() && { + return {std::move(this->leader_parts), __isset.leader_parts}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template >> + FOLLY_ERASE ::apache::thrift::field_ref all_parts_ref() const& { + return {this->all_parts, __isset.all_parts}; + } + + template >> + FOLLY_ERASE ::apache::thrift::field_ref all_parts_ref() const&& { + return {std::move(this->all_parts), __isset.all_parts}; + } + + template >> + FOLLY_ERASE ::apache::thrift::field_ref all_parts_ref() & { + return {this->all_parts, __isset.all_parts}; + } + + template >> + FOLLY_ERASE ::apache::thrift::field_ref all_parts_ref() && { + return {std::move(this->all_parts), __isset.all_parts}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref role_ref() const& { + return {this->role, __isset.role}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref role_ref() const&& { + return {std::move(this->role), __isset.role}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref role_ref() & { + return {this->role, __isset.role}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref role_ref() && { + return {std::move(this->role), __isset.role}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref git_info_sha_ref() const& { + return {this->git_info_sha, __isset.git_info_sha}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref git_info_sha_ref() const&& { + return {std::move(this->git_info_sha), __isset.git_info_sha}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref git_info_sha_ref() & { + return {this->git_info_sha, __isset.git_info_sha}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref git_info_sha_ref() && { + return {std::move(this->git_info_sha), __isset.git_info_sha}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::optional_field_ref zone_name_ref() const& { + return {this->zone_name, __isset.zone_name}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref zone_name_ref() const&& { + return {std::move(this->zone_name), __isset.zone_name}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref zone_name_ref() & { + return {this->zone_name, __isset.zone_name}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref zone_name_ref() && { + return {std::move(this->zone_name), __isset.zone_name}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::optional_field_ref version_ref() const& { + return {this->version, __isset.version}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref version_ref() const&& { + return {std::move(this->version), __isset.version}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref version_ref() & { + return {this->version, __isset.version}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref version_ref() && { + return {std::move(this->version), __isset.version}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + const nebula::HostAddr& get_hostAddr() const&; + nebula::HostAddr get_hostAddr() &&; + + template + nebula::HostAddr& set_hostAddr(T_HostItem_hostAddr_struct_setter&& hostAddr_) { + hostAddr = std::forward(hostAddr_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.hostAddr = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return hostAddr; + } + + ::nebula::meta::cpp2::HostStatus get_status() const { + return status; + } + + ::nebula::meta::cpp2::HostStatus& set_status( ::nebula::meta::cpp2::HostStatus status_) { + status = status_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.status = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return status; + } + const std::unordered_map<::std::string, ::std::vector< ::nebula::cpp2::PartitionID>>& get_leader_parts() const&; + std::unordered_map<::std::string, ::std::vector< ::nebula::cpp2::PartitionID>> get_leader_parts() &&; + + template >> + std::unordered_map<::std::string, ::std::vector< ::nebula::cpp2::PartitionID>>& set_leader_parts(T_HostItem_leader_parts_struct_setter&& leader_parts_) { + leader_parts = std::forward(leader_parts_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.leader_parts = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return leader_parts; + } + const std::unordered_map<::std::string, ::std::vector< ::nebula::cpp2::PartitionID>>& get_all_parts() const&; + std::unordered_map<::std::string, ::std::vector< ::nebula::cpp2::PartitionID>> get_all_parts() &&; + + template >> + std::unordered_map<::std::string, ::std::vector< ::nebula::cpp2::PartitionID>>& set_all_parts(T_HostItem_all_parts_struct_setter&& all_parts_) { + all_parts = std::forward(all_parts_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.all_parts = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return all_parts; + } + + ::nebula::meta::cpp2::HostRole get_role() const { + return role; + } + + ::nebula::meta::cpp2::HostRole& set_role( ::nebula::meta::cpp2::HostRole role_) { + role = role_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.role = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return role; + } + + const ::std::string& get_git_info_sha() const& { + return git_info_sha; + } + + ::std::string get_git_info_sha() && { + return std::move(git_info_sha); + } + + template + ::std::string& set_git_info_sha(T_HostItem_git_info_sha_struct_setter&& git_info_sha_) { + git_info_sha = std::forward(git_info_sha_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.git_info_sha = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return git_info_sha; + } + + const ::std::string* get_zone_name() const& { + return zone_name_ref() ? std::addressof(zone_name) : nullptr; + } + + ::std::string* get_zone_name() & { + return zone_name_ref() ? std::addressof(zone_name) : nullptr; + } + ::std::string* get_zone_name() && = delete; + + template + ::std::string& set_zone_name(T_HostItem_zone_name_struct_setter&& zone_name_) { + zone_name = std::forward(zone_name_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.zone_name = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return zone_name; + } + + const ::std::string* get_version() const& { + return version_ref() ? std::addressof(version) : nullptr; + } + + ::std::string* get_version() & { + return version_ref() ? std::addressof(version) : nullptr; + } + ::std::string* get_version() && = delete; + + template + ::std::string& set_version(T_HostItem_version_struct_setter&& version_) { + version = std::forward(version_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.version = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return version; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< HostItem >; + friend void swap(HostItem& a, HostItem& b); +}; + +template +uint32_t HostItem::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class UserItem final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = UserItem; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + + UserItem(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + UserItem(apache::thrift::FragileConstructor, ::std::string account__arg, bool is_lock__arg, int32_t max_queries_per_hour__arg, int32_t max_updates_per_hour__arg, int32_t max_connections_per_hour__arg, int32_t max_user_connections__arg); + + UserItem(UserItem&&) = default; + + UserItem(const UserItem&) = default; + + + UserItem& operator=(UserItem&&) = default; + + UserItem& operator=(const UserItem&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + + ~UserItem(); + + private: + ::std::string account; + private: + bool is_lock; + private: + int32_t max_queries_per_hour; + private: + int32_t max_updates_per_hour; + private: + int32_t max_connections_per_hour; + private: + int32_t max_user_connections; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool account; + bool is_lock; + bool max_queries_per_hour; + bool max_updates_per_hour; + bool max_connections_per_hour; + bool max_user_connections; + } __isset = {}; + bool operator==(const UserItem& rhs) const; +#ifndef SWIG + friend bool operator!=(const UserItem& __x, const UserItem& __y) { + return !(__x == __y); + } +#endif + bool operator<(const UserItem& rhs) const; +#ifndef SWIG + friend bool operator>(const UserItem& __x, const UserItem& __y) { + return __y < __x; + } + friend bool operator<=(const UserItem& __x, const UserItem& __y) { + return !(__y < __x); + } + friend bool operator>=(const UserItem& __x, const UserItem& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref account_ref() const& { + return {this->account, __isset.account}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref account_ref() const&& { + return {std::move(this->account), __isset.account}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref account_ref() & { + return {this->account, __isset.account}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref account_ref() && { + return {std::move(this->account), __isset.account}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref is_lock_ref() const& { + return {this->is_lock, __isset.is_lock}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref is_lock_ref() const&& { + return {std::move(this->is_lock), __isset.is_lock}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref is_lock_ref() & { + return {this->is_lock, __isset.is_lock}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref is_lock_ref() && { + return {std::move(this->is_lock), __isset.is_lock}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref max_queries_per_hour_ref() const& { + return {this->max_queries_per_hour, __isset.max_queries_per_hour}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref max_queries_per_hour_ref() const&& { + return {std::move(this->max_queries_per_hour), __isset.max_queries_per_hour}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref max_queries_per_hour_ref() & { + return {this->max_queries_per_hour, __isset.max_queries_per_hour}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref max_queries_per_hour_ref() && { + return {std::move(this->max_queries_per_hour), __isset.max_queries_per_hour}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref max_updates_per_hour_ref() const& { + return {this->max_updates_per_hour, __isset.max_updates_per_hour}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref max_updates_per_hour_ref() const&& { + return {std::move(this->max_updates_per_hour), __isset.max_updates_per_hour}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref max_updates_per_hour_ref() & { + return {this->max_updates_per_hour, __isset.max_updates_per_hour}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref max_updates_per_hour_ref() && { + return {std::move(this->max_updates_per_hour), __isset.max_updates_per_hour}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref max_connections_per_hour_ref() const& { + return {this->max_connections_per_hour, __isset.max_connections_per_hour}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref max_connections_per_hour_ref() const&& { + return {std::move(this->max_connections_per_hour), __isset.max_connections_per_hour}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref max_connections_per_hour_ref() & { + return {this->max_connections_per_hour, __isset.max_connections_per_hour}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref max_connections_per_hour_ref() && { + return {std::move(this->max_connections_per_hour), __isset.max_connections_per_hour}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref max_user_connections_ref() const& { + return {this->max_user_connections, __isset.max_user_connections}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref max_user_connections_ref() const&& { + return {std::move(this->max_user_connections), __isset.max_user_connections}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref max_user_connections_ref() & { + return {this->max_user_connections, __isset.max_user_connections}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref max_user_connections_ref() && { + return {std::move(this->max_user_connections), __isset.max_user_connections}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + const ::std::string& get_account() const& { + return account; + } + + ::std::string get_account() && { + return std::move(account); + } + + template + ::std::string& set_account(T_UserItem_account_struct_setter&& account_) { + account = std::forward(account_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.account = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return account; + } + + bool get_is_lock() const { + return is_lock; + } + + bool& set_is_lock(bool is_lock_) { + is_lock = is_lock_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.is_lock = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return is_lock; + } + + int32_t get_max_queries_per_hour() const { + return max_queries_per_hour; + } + + int32_t& set_max_queries_per_hour(int32_t max_queries_per_hour_) { + max_queries_per_hour = max_queries_per_hour_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.max_queries_per_hour = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return max_queries_per_hour; + } + + int32_t get_max_updates_per_hour() const { + return max_updates_per_hour; + } + + int32_t& set_max_updates_per_hour(int32_t max_updates_per_hour_) { + max_updates_per_hour = max_updates_per_hour_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.max_updates_per_hour = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return max_updates_per_hour; + } + + int32_t get_max_connections_per_hour() const { + return max_connections_per_hour; + } + + int32_t& set_max_connections_per_hour(int32_t max_connections_per_hour_) { + max_connections_per_hour = max_connections_per_hour_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.max_connections_per_hour = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return max_connections_per_hour; + } + + int32_t get_max_user_connections() const { + return max_user_connections; + } + + int32_t& set_max_user_connections(int32_t max_user_connections_) { + max_user_connections = max_user_connections_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.max_user_connections = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return max_user_connections; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< UserItem >; + friend void swap(UserItem& a, UserItem& b); +}; + +template +uint32_t UserItem::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class RoleItem final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = RoleItem; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + RoleItem() : + space_id(0), + role_type(static_cast< ::nebula::meta::cpp2::RoleType>(0)) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + RoleItem(apache::thrift::FragileConstructor, ::std::string user_id__arg, ::nebula::cpp2::GraphSpaceID space_id__arg, ::nebula::meta::cpp2::RoleType role_type__arg); + + RoleItem(RoleItem&&) = default; + + RoleItem(const RoleItem&) = default; + + + RoleItem& operator=(RoleItem&&) = default; + + RoleItem& operator=(const RoleItem&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::std::string user_id; + private: + ::nebula::cpp2::GraphSpaceID space_id; + private: + ::nebula::meta::cpp2::RoleType role_type; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool user_id; + bool space_id; + bool role_type; + } __isset = {}; + bool operator==(const RoleItem& rhs) const; +#ifndef SWIG + friend bool operator!=(const RoleItem& __x, const RoleItem& __y) { + return !(__x == __y); + } +#endif + bool operator<(const RoleItem& rhs) const; +#ifndef SWIG + friend bool operator>(const RoleItem& __x, const RoleItem& __y) { + return __y < __x; + } + friend bool operator<=(const RoleItem& __x, const RoleItem& __y) { + return !(__y < __x); + } + friend bool operator>=(const RoleItem& __x, const RoleItem& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref user_id_ref() const& { + return {this->user_id, __isset.user_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref user_id_ref() const&& { + return {std::move(this->user_id), __isset.user_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref user_id_ref() & { + return {this->user_id, __isset.user_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref user_id_ref() && { + return {std::move(this->user_id), __isset.user_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const& { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const&& { + return {std::move(this->space_id), __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() & { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() && { + return {std::move(this->space_id), __isset.space_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref role_type_ref() const& { + return {this->role_type, __isset.role_type}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref role_type_ref() const&& { + return {std::move(this->role_type), __isset.role_type}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref role_type_ref() & { + return {this->role_type, __isset.role_type}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref role_type_ref() && { + return {std::move(this->role_type), __isset.role_type}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + const ::std::string& get_user_id() const& { + return user_id; + } + + ::std::string get_user_id() && { + return std::move(user_id); + } + + template + ::std::string& set_user_id(T_RoleItem_user_id_struct_setter&& user_id_) { + user_id = std::forward(user_id_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.user_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return user_id; + } + + ::nebula::cpp2::GraphSpaceID get_space_id() const { + return space_id; + } + + ::nebula::cpp2::GraphSpaceID& set_space_id( ::nebula::cpp2::GraphSpaceID space_id_) { + space_id = space_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.space_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return space_id; + } + + ::nebula::meta::cpp2::RoleType get_role_type() const { + return role_type; + } + + ::nebula::meta::cpp2::RoleType& set_role_type( ::nebula::meta::cpp2::RoleType role_type_) { + role_type = role_type_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.role_type = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return role_type; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< RoleItem >; + friend void swap(RoleItem& a, RoleItem& b); +}; + +template +uint32_t RoleItem::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class ExecResp final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = ExecResp; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + ExecResp() : + code( ::nebula::cpp2::ErrorCode::SUCCEEDED) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + ExecResp(apache::thrift::FragileConstructor, ::nebula::cpp2::ErrorCode code__arg, ::nebula::meta::cpp2::ID id__arg, nebula::HostAddr leader__arg); + + ExecResp(ExecResp&&) = default; + + ExecResp(const ExecResp&) = default; + + + ExecResp& operator=(ExecResp&&) = default; + + ExecResp& operator=(const ExecResp&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::ErrorCode code; + private: + ::nebula::meta::cpp2::ID id; + private: + nebula::HostAddr leader; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool code; + bool id; + bool leader; + } __isset = {}; + bool operator==(const ExecResp& rhs) const; +#ifndef SWIG + friend bool operator!=(const ExecResp& __x, const ExecResp& __y) { + return !(__x == __y); + } +#endif + bool operator<(const ExecResp& rhs) const; +#ifndef SWIG + friend bool operator>(const ExecResp& __x, const ExecResp& __y) { + return __y < __x; + } + friend bool operator<=(const ExecResp& __x, const ExecResp& __y) { + return !(__y < __x); + } + friend bool operator>=(const ExecResp& __x, const ExecResp& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() const& { + return {this->code, __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() const&& { + return {std::move(this->code), __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() & { + return {this->code, __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() && { + return {std::move(this->code), __isset.code}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref id_ref() const& { + return {this->id, __isset.id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref id_ref() const&& { + return {std::move(this->id), __isset.id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref id_ref() & { + return {this->id, __isset.id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref id_ref() && { + return {std::move(this->id), __isset.id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() const& { + return {this->leader, __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() const&& { + return {std::move(this->leader), __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() & { + return {this->leader, __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() && { + return {std::move(this->leader), __isset.leader}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::ErrorCode get_code() const { + return code; + } + + ::nebula::cpp2::ErrorCode& set_code( ::nebula::cpp2::ErrorCode code_) { + code = code_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.code = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return code; + } + const ::nebula::meta::cpp2::ID& get_id() const&; + ::nebula::meta::cpp2::ID get_id() &&; + + template + ::nebula::meta::cpp2::ID& set_id(T_ExecResp_id_struct_setter&& id_) { + id = std::forward(id_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return id; + } + const nebula::HostAddr& get_leader() const&; + nebula::HostAddr get_leader() &&; + + template + nebula::HostAddr& set_leader(T_ExecResp_leader_struct_setter&& leader_) { + leader = std::forward(leader_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.leader = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return leader; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< ExecResp >; + friend void swap(ExecResp& a, ExecResp& b); +}; + +template +uint32_t ExecResp::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class AdminJobReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = AdminJobReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + AdminJobReq() : + op(static_cast< ::nebula::meta::cpp2::AdminJobOp>(0)), + cmd( ::nebula::meta::cpp2::AdminCmd::COMPACT) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + AdminJobReq(apache::thrift::FragileConstructor, ::nebula::meta::cpp2::AdminJobOp op__arg, ::nebula::meta::cpp2::AdminCmd cmd__arg, ::std::vector<::std::string> paras__arg); + + AdminJobReq(AdminJobReq&&) = default; + + AdminJobReq(const AdminJobReq&) = default; + + + AdminJobReq& operator=(AdminJobReq&&) = default; + + AdminJobReq& operator=(const AdminJobReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::meta::cpp2::AdminJobOp op; + private: + ::nebula::meta::cpp2::AdminCmd cmd; + private: + ::std::vector<::std::string> paras; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool op; + bool cmd; + bool paras; + } __isset = {}; + bool operator==(const AdminJobReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const AdminJobReq& __x, const AdminJobReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const AdminJobReq& rhs) const; +#ifndef SWIG + friend bool operator>(const AdminJobReq& __x, const AdminJobReq& __y) { + return __y < __x; + } + friend bool operator<=(const AdminJobReq& __x, const AdminJobReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const AdminJobReq& __x, const AdminJobReq& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref op_ref() const& { + return {this->op, __isset.op}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref op_ref() const&& { + return {std::move(this->op), __isset.op}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref op_ref() & { + return {this->op, __isset.op}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref op_ref() && { + return {std::move(this->op), __isset.op}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref cmd_ref() const& { + return {this->cmd, __isset.cmd}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref cmd_ref() const&& { + return {std::move(this->cmd), __isset.cmd}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref cmd_ref() & { + return {this->cmd, __isset.cmd}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref cmd_ref() && { + return {std::move(this->cmd), __isset.cmd}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::field_ref paras_ref() const& { + return {this->paras, __isset.paras}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref paras_ref() const&& { + return {std::move(this->paras), __isset.paras}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref paras_ref() & { + return {this->paras, __isset.paras}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref paras_ref() && { + return {std::move(this->paras), __isset.paras}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::meta::cpp2::AdminJobOp get_op() const { + return op; + } + + ::nebula::meta::cpp2::AdminJobOp& set_op( ::nebula::meta::cpp2::AdminJobOp op_) { + op = op_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.op = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return op; + } + + ::nebula::meta::cpp2::AdminCmd get_cmd() const { + return cmd; + } + + ::nebula::meta::cpp2::AdminCmd& set_cmd( ::nebula::meta::cpp2::AdminCmd cmd_) { + cmd = cmd_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.cmd = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return cmd; + } + const ::std::vector<::std::string>& get_paras() const&; + ::std::vector<::std::string> get_paras() &&; + + template > + ::std::vector<::std::string>& set_paras(T_AdminJobReq_paras_struct_setter&& paras_) { + paras = std::forward(paras_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.paras = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return paras; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< AdminJobReq >; + friend void swap(AdminJobReq& a, AdminJobReq& b); +}; + +template +uint32_t AdminJobReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class JobDesc final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = JobDesc; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + + JobDesc(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + JobDesc(apache::thrift::FragileConstructor, int32_t id__arg, ::nebula::meta::cpp2::AdminCmd cmd__arg, ::std::vector<::std::string> paras__arg, ::nebula::meta::cpp2::JobStatus status__arg, int64_t start_time__arg, int64_t stop_time__arg); + + JobDesc(JobDesc&&) = default; + + JobDesc(const JobDesc&) = default; + + + JobDesc& operator=(JobDesc&&) = default; + + JobDesc& operator=(const JobDesc&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + + ~JobDesc(); + + private: + int32_t id; + private: + ::nebula::meta::cpp2::AdminCmd cmd; + private: + ::std::vector<::std::string> paras; + private: + ::nebula::meta::cpp2::JobStatus status; + private: + int64_t start_time; + private: + int64_t stop_time; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool id; + bool cmd; + bool paras; + bool status; + bool start_time; + bool stop_time; + } __isset = {}; + bool operator==(const JobDesc& rhs) const; +#ifndef SWIG + friend bool operator!=(const JobDesc& __x, const JobDesc& __y) { + return !(__x == __y); + } +#endif + bool operator<(const JobDesc& rhs) const; +#ifndef SWIG + friend bool operator>(const JobDesc& __x, const JobDesc& __y) { + return __y < __x; + } + friend bool operator<=(const JobDesc& __x, const JobDesc& __y) { + return !(__y < __x); + } + friend bool operator>=(const JobDesc& __x, const JobDesc& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref id_ref() const& { + return {this->id, __isset.id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref id_ref() const&& { + return {std::move(this->id), __isset.id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref id_ref() & { + return {this->id, __isset.id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref id_ref() && { + return {std::move(this->id), __isset.id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref cmd_ref() const& { + return {this->cmd, __isset.cmd}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref cmd_ref() const&& { + return {std::move(this->cmd), __isset.cmd}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref cmd_ref() & { + return {this->cmd, __isset.cmd}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref cmd_ref() && { + return {std::move(this->cmd), __isset.cmd}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::field_ref paras_ref() const& { + return {this->paras, __isset.paras}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref paras_ref() const&& { + return {std::move(this->paras), __isset.paras}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref paras_ref() & { + return {this->paras, __isset.paras}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref paras_ref() && { + return {std::move(this->paras), __isset.paras}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref status_ref() const& { + return {this->status, __isset.status}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref status_ref() const&& { + return {std::move(this->status), __isset.status}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref status_ref() & { + return {this->status, __isset.status}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref status_ref() && { + return {std::move(this->status), __isset.status}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref start_time_ref() const& { + return {this->start_time, __isset.start_time}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref start_time_ref() const&& { + return {std::move(this->start_time), __isset.start_time}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref start_time_ref() & { + return {this->start_time, __isset.start_time}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref start_time_ref() && { + return {std::move(this->start_time), __isset.start_time}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref stop_time_ref() const& { + return {this->stop_time, __isset.stop_time}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref stop_time_ref() const&& { + return {std::move(this->stop_time), __isset.stop_time}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref stop_time_ref() & { + return {this->stop_time, __isset.stop_time}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref stop_time_ref() && { + return {std::move(this->stop_time), __isset.stop_time}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + int32_t get_id() const { + return id; + } + + int32_t& set_id(int32_t id_) { + id = id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return id; + } + + ::nebula::meta::cpp2::AdminCmd get_cmd() const { + return cmd; + } + + ::nebula::meta::cpp2::AdminCmd& set_cmd( ::nebula::meta::cpp2::AdminCmd cmd_) { + cmd = cmd_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.cmd = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return cmd; + } + const ::std::vector<::std::string>& get_paras() const&; + ::std::vector<::std::string> get_paras() &&; + + template > + ::std::vector<::std::string>& set_paras(T_JobDesc_paras_struct_setter&& paras_) { + paras = std::forward(paras_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.paras = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return paras; + } + + ::nebula::meta::cpp2::JobStatus get_status() const { + return status; + } + + ::nebula::meta::cpp2::JobStatus& set_status( ::nebula::meta::cpp2::JobStatus status_) { + status = status_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.status = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return status; + } + + int64_t get_start_time() const { + return start_time; + } + + int64_t& set_start_time(int64_t start_time_) { + start_time = start_time_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.start_time = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return start_time; + } + + int64_t get_stop_time() const { + return stop_time; + } + + int64_t& set_stop_time(int64_t stop_time_) { + stop_time = stop_time_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.stop_time = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return stop_time; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< JobDesc >; + friend void swap(JobDesc& a, JobDesc& b); +}; + +template +uint32_t JobDesc::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class TaskDesc final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = TaskDesc; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + TaskDesc() : + task_id(0), + status(static_cast< ::nebula::meta::cpp2::JobStatus>(0)), + start_time(0), + stop_time(0), + job_id(0) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + TaskDesc(apache::thrift::FragileConstructor, int32_t task_id__arg, nebula::HostAddr host__arg, ::nebula::meta::cpp2::JobStatus status__arg, int64_t start_time__arg, int64_t stop_time__arg, int32_t job_id__arg); + + TaskDesc(TaskDesc&&) = default; + + TaskDesc(const TaskDesc&) = default; + + + TaskDesc& operator=(TaskDesc&&) = default; + + TaskDesc& operator=(const TaskDesc&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + int32_t task_id; + private: + nebula::HostAddr host; + private: + ::nebula::meta::cpp2::JobStatus status; + private: + int64_t start_time; + private: + int64_t stop_time; + private: + int32_t job_id; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool task_id; + bool host; + bool status; + bool start_time; + bool stop_time; + bool job_id; + } __isset = {}; + bool operator==(const TaskDesc& rhs) const; +#ifndef SWIG + friend bool operator!=(const TaskDesc& __x, const TaskDesc& __y) { + return !(__x == __y); + } +#endif + bool operator<(const TaskDesc& rhs) const; +#ifndef SWIG + friend bool operator>(const TaskDesc& __x, const TaskDesc& __y) { + return __y < __x; + } + friend bool operator<=(const TaskDesc& __x, const TaskDesc& __y) { + return !(__y < __x); + } + friend bool operator>=(const TaskDesc& __x, const TaskDesc& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref task_id_ref() const& { + return {this->task_id, __isset.task_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref task_id_ref() const&& { + return {std::move(this->task_id), __isset.task_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref task_id_ref() & { + return {this->task_id, __isset.task_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref task_id_ref() && { + return {std::move(this->task_id), __isset.task_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref host_ref() const& { + return {this->host, __isset.host}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref host_ref() const&& { + return {std::move(this->host), __isset.host}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref host_ref() & { + return {this->host, __isset.host}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref host_ref() && { + return {std::move(this->host), __isset.host}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref status_ref() const& { + return {this->status, __isset.status}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref status_ref() const&& { + return {std::move(this->status), __isset.status}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref status_ref() & { + return {this->status, __isset.status}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref status_ref() && { + return {std::move(this->status), __isset.status}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref start_time_ref() const& { + return {this->start_time, __isset.start_time}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref start_time_ref() const&& { + return {std::move(this->start_time), __isset.start_time}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref start_time_ref() & { + return {this->start_time, __isset.start_time}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref start_time_ref() && { + return {std::move(this->start_time), __isset.start_time}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref stop_time_ref() const& { + return {this->stop_time, __isset.stop_time}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref stop_time_ref() const&& { + return {std::move(this->stop_time), __isset.stop_time}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref stop_time_ref() & { + return {this->stop_time, __isset.stop_time}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref stop_time_ref() && { + return {std::move(this->stop_time), __isset.stop_time}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref job_id_ref() const& { + return {this->job_id, __isset.job_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref job_id_ref() const&& { + return {std::move(this->job_id), __isset.job_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref job_id_ref() & { + return {this->job_id, __isset.job_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref job_id_ref() && { + return {std::move(this->job_id), __isset.job_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + int32_t get_task_id() const { + return task_id; + } + + int32_t& set_task_id(int32_t task_id_) { + task_id = task_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.task_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return task_id; + } + const nebula::HostAddr& get_host() const&; + nebula::HostAddr get_host() &&; + + template + nebula::HostAddr& set_host(T_TaskDesc_host_struct_setter&& host_) { + host = std::forward(host_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.host = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return host; + } + + ::nebula::meta::cpp2::JobStatus get_status() const { + return status; + } + + ::nebula::meta::cpp2::JobStatus& set_status( ::nebula::meta::cpp2::JobStatus status_) { + status = status_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.status = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return status; + } + + int64_t get_start_time() const { + return start_time; + } + + int64_t& set_start_time(int64_t start_time_) { + start_time = start_time_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.start_time = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return start_time; + } + + int64_t get_stop_time() const { + return stop_time; + } + + int64_t& set_stop_time(int64_t stop_time_) { + stop_time = stop_time_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.stop_time = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return stop_time; + } + + int32_t get_job_id() const { + return job_id; + } + + int32_t& set_job_id(int32_t job_id_) { + job_id = job_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.job_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return job_id; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< TaskDesc >; + friend void swap(TaskDesc& a, TaskDesc& b); +}; + +template +uint32_t TaskDesc::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class AdminJobResult final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = AdminJobResult; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + AdminJobResult() : + job_id(0), + recovered_job_num(0) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + AdminJobResult(apache::thrift::FragileConstructor, int32_t job_id__arg, ::std::vector< ::nebula::meta::cpp2::JobDesc> job_desc__arg, ::std::vector< ::nebula::meta::cpp2::TaskDesc> task_desc__arg, int32_t recovered_job_num__arg); + + AdminJobResult(AdminJobResult&&) = default; + + AdminJobResult(const AdminJobResult&) = default; + + + AdminJobResult& operator=(AdminJobResult&&) = default; + + AdminJobResult& operator=(const AdminJobResult&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + int32_t job_id; + private: + ::std::vector< ::nebula::meta::cpp2::JobDesc> job_desc; + private: + ::std::vector< ::nebula::meta::cpp2::TaskDesc> task_desc; + private: + int32_t recovered_job_num; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool job_id; + bool job_desc; + bool task_desc; + bool recovered_job_num; + } __isset = {}; + bool operator==(const AdminJobResult& rhs) const; +#ifndef SWIG + friend bool operator!=(const AdminJobResult& __x, const AdminJobResult& __y) { + return !(__x == __y); + } +#endif + bool operator<(const AdminJobResult& rhs) const; +#ifndef SWIG + friend bool operator>(const AdminJobResult& __x, const AdminJobResult& __y) { + return __y < __x; + } + friend bool operator<=(const AdminJobResult& __x, const AdminJobResult& __y) { + return !(__y < __x); + } + friend bool operator>=(const AdminJobResult& __x, const AdminJobResult& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::optional_field_ref job_id_ref() const& { + return {this->job_id, __isset.job_id}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref job_id_ref() const&& { + return {std::move(this->job_id), __isset.job_id}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref job_id_ref() & { + return {this->job_id, __isset.job_id}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref job_id_ref() && { + return {std::move(this->job_id), __isset.job_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::optional_field_ref job_desc_ref() const& { + return {this->job_desc, __isset.job_desc}; + } + + template > + FOLLY_ERASE ::apache::thrift::optional_field_ref job_desc_ref() const&& { + return {std::move(this->job_desc), __isset.job_desc}; + } + + template > + FOLLY_ERASE ::apache::thrift::optional_field_ref job_desc_ref() & { + return {this->job_desc, __isset.job_desc}; + } + + template > + FOLLY_ERASE ::apache::thrift::optional_field_ref job_desc_ref() && { + return {std::move(this->job_desc), __isset.job_desc}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::optional_field_ref task_desc_ref() const& { + return {this->task_desc, __isset.task_desc}; + } + + template > + FOLLY_ERASE ::apache::thrift::optional_field_ref task_desc_ref() const&& { + return {std::move(this->task_desc), __isset.task_desc}; + } + + template > + FOLLY_ERASE ::apache::thrift::optional_field_ref task_desc_ref() & { + return {this->task_desc, __isset.task_desc}; + } + + template > + FOLLY_ERASE ::apache::thrift::optional_field_ref task_desc_ref() && { + return {std::move(this->task_desc), __isset.task_desc}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::optional_field_ref recovered_job_num_ref() const& { + return {this->recovered_job_num, __isset.recovered_job_num}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref recovered_job_num_ref() const&& { + return {std::move(this->recovered_job_num), __isset.recovered_job_num}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref recovered_job_num_ref() & { + return {this->recovered_job_num, __isset.recovered_job_num}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref recovered_job_num_ref() && { + return {std::move(this->recovered_job_num), __isset.recovered_job_num}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + const int32_t* get_job_id() const& { + return job_id_ref() ? std::addressof(job_id) : nullptr; + } + + int32_t* get_job_id() & { + return job_id_ref() ? std::addressof(job_id) : nullptr; + } + int32_t* get_job_id() && = delete; + + int32_t& set_job_id(int32_t job_id_) { + job_id = job_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.job_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return job_id; + } + const ::std::vector< ::nebula::meta::cpp2::JobDesc>* get_job_desc() const&; + ::std::vector< ::nebula::meta::cpp2::JobDesc>* get_job_desc() &; + ::std::vector< ::nebula::meta::cpp2::JobDesc>* get_job_desc() && = delete; + + template > + ::std::vector< ::nebula::meta::cpp2::JobDesc>& set_job_desc(T_AdminJobResult_job_desc_struct_setter&& job_desc_) { + job_desc = std::forward(job_desc_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.job_desc = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return job_desc; + } + const ::std::vector< ::nebula::meta::cpp2::TaskDesc>* get_task_desc() const&; + ::std::vector< ::nebula::meta::cpp2::TaskDesc>* get_task_desc() &; + ::std::vector< ::nebula::meta::cpp2::TaskDesc>* get_task_desc() && = delete; + + template > + ::std::vector< ::nebula::meta::cpp2::TaskDesc>& set_task_desc(T_AdminJobResult_task_desc_struct_setter&& task_desc_) { + task_desc = std::forward(task_desc_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.task_desc = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return task_desc; + } + + const int32_t* get_recovered_job_num() const& { + return recovered_job_num_ref() ? std::addressof(recovered_job_num) : nullptr; + } + + int32_t* get_recovered_job_num() & { + return recovered_job_num_ref() ? std::addressof(recovered_job_num) : nullptr; + } + int32_t* get_recovered_job_num() && = delete; + + int32_t& set_recovered_job_num(int32_t recovered_job_num_) { + recovered_job_num = recovered_job_num_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.recovered_job_num = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return recovered_job_num; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< AdminJobResult >; + friend void swap(AdminJobResult& a, AdminJobResult& b); +}; + +template +uint32_t AdminJobResult::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class AdminJobResp final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = AdminJobResp; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + AdminJobResp() : + code( ::nebula::cpp2::ErrorCode::SUCCEEDED) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + AdminJobResp(apache::thrift::FragileConstructor, ::nebula::cpp2::ErrorCode code__arg, nebula::HostAddr leader__arg, ::nebula::meta::cpp2::AdminJobResult result__arg); + + AdminJobResp(AdminJobResp&&) = default; + + AdminJobResp(const AdminJobResp&) = default; + + + AdminJobResp& operator=(AdminJobResp&&) = default; + + AdminJobResp& operator=(const AdminJobResp&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::ErrorCode code; + private: + nebula::HostAddr leader; + private: + ::nebula::meta::cpp2::AdminJobResult result; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool code; + bool leader; + bool result; + } __isset = {}; + bool operator==(const AdminJobResp& rhs) const; +#ifndef SWIG + friend bool operator!=(const AdminJobResp& __x, const AdminJobResp& __y) { + return !(__x == __y); + } +#endif + bool operator<(const AdminJobResp& rhs) const; +#ifndef SWIG + friend bool operator>(const AdminJobResp& __x, const AdminJobResp& __y) { + return __y < __x; + } + friend bool operator<=(const AdminJobResp& __x, const AdminJobResp& __y) { + return !(__y < __x); + } + friend bool operator>=(const AdminJobResp& __x, const AdminJobResp& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() const& { + return {this->code, __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() const&& { + return {std::move(this->code), __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() & { + return {this->code, __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() && { + return {std::move(this->code), __isset.code}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() const& { + return {this->leader, __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() const&& { + return {std::move(this->leader), __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() & { + return {this->leader, __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() && { + return {std::move(this->leader), __isset.leader}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref result_ref() const& { + return {this->result, __isset.result}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref result_ref() const&& { + return {std::move(this->result), __isset.result}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref result_ref() & { + return {this->result, __isset.result}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref result_ref() && { + return {std::move(this->result), __isset.result}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::ErrorCode get_code() const { + return code; + } + + ::nebula::cpp2::ErrorCode& set_code( ::nebula::cpp2::ErrorCode code_) { + code = code_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.code = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return code; + } + const nebula::HostAddr& get_leader() const&; + nebula::HostAddr get_leader() &&; + + template + nebula::HostAddr& set_leader(T_AdminJobResp_leader_struct_setter&& leader_) { + leader = std::forward(leader_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.leader = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return leader; + } + const ::nebula::meta::cpp2::AdminJobResult& get_result() const&; + ::nebula::meta::cpp2::AdminJobResult get_result() &&; + + template + ::nebula::meta::cpp2::AdminJobResult& set_result(T_AdminJobResp_result_struct_setter&& result_) { + result = std::forward(result_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.result = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return result; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< AdminJobResp >; + friend void swap(AdminJobResp& a, AdminJobResp& b); +}; + +template +uint32_t AdminJobResp::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class Correlativity final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = Correlativity; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + Correlativity() : + part_id(0), + proportion(0) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + Correlativity(apache::thrift::FragileConstructor, ::nebula::cpp2::PartitionID part_id__arg, double proportion__arg); + + Correlativity(Correlativity&&) = default; + + Correlativity(const Correlativity&) = default; + + + Correlativity& operator=(Correlativity&&) = default; + + Correlativity& operator=(const Correlativity&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::PartitionID part_id; + private: + double proportion; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool part_id; + bool proportion; + } __isset = {}; + bool operator==(const Correlativity& rhs) const; +#ifndef SWIG + friend bool operator!=(const Correlativity& __x, const Correlativity& __y) { + return !(__x == __y); + } +#endif + bool operator<(const Correlativity& rhs) const; +#ifndef SWIG + friend bool operator>(const Correlativity& __x, const Correlativity& __y) { + return __y < __x; + } + friend bool operator<=(const Correlativity& __x, const Correlativity& __y) { + return !(__y < __x); + } + friend bool operator>=(const Correlativity& __x, const Correlativity& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref part_id_ref() const& { + return {this->part_id, __isset.part_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref part_id_ref() const&& { + return {std::move(this->part_id), __isset.part_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref part_id_ref() & { + return {this->part_id, __isset.part_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref part_id_ref() && { + return {std::move(this->part_id), __isset.part_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref proportion_ref() const& { + return {this->proportion, __isset.proportion}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref proportion_ref() const&& { + return {std::move(this->proportion), __isset.proportion}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref proportion_ref() & { + return {this->proportion, __isset.proportion}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref proportion_ref() && { + return {std::move(this->proportion), __isset.proportion}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::PartitionID get_part_id() const { + return part_id; + } + + ::nebula::cpp2::PartitionID& set_part_id( ::nebula::cpp2::PartitionID part_id_) { + part_id = part_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.part_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return part_id; + } + + double get_proportion() const { + return proportion; + } + + double& set_proportion(double proportion_) { + proportion = proportion_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.proportion = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return proportion; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< Correlativity >; + friend void swap(Correlativity& a, Correlativity& b); +}; + +template +uint32_t Correlativity::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class StatsItem final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = StatsItem; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + + StatsItem(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + StatsItem(apache::thrift::FragileConstructor, std::unordered_map<::std::string, int64_t> tag_vertices__arg, std::unordered_map<::std::string, int64_t> edges__arg, int64_t space_vertices__arg, int64_t space_edges__arg, std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::meta::cpp2::Correlativity>> positive_part_correlativity__arg, std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::meta::cpp2::Correlativity>> negative_part_correlativity__arg, ::nebula::meta::cpp2::JobStatus status__arg); + + StatsItem(StatsItem&&) = default; + + StatsItem(const StatsItem&) = default; + + + StatsItem& operator=(StatsItem&&) = default; + + StatsItem& operator=(const StatsItem&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + + ~StatsItem(); + + private: + std::unordered_map<::std::string, int64_t> tag_vertices; + private: + std::unordered_map<::std::string, int64_t> edges; + private: + int64_t space_vertices; + private: + int64_t space_edges; + private: + std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::meta::cpp2::Correlativity>> positive_part_correlativity; + private: + std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::meta::cpp2::Correlativity>> negative_part_correlativity; + private: + ::nebula::meta::cpp2::JobStatus status; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool tag_vertices; + bool edges; + bool space_vertices; + bool space_edges; + bool positive_part_correlativity; + bool negative_part_correlativity; + bool status; + } __isset = {}; + bool operator==(const StatsItem& rhs) const; +#ifndef SWIG + friend bool operator!=(const StatsItem& __x, const StatsItem& __y) { + return !(__x == __y); + } +#endif + bool operator<(const StatsItem& rhs) const; +#ifndef SWIG + friend bool operator>(const StatsItem& __x, const StatsItem& __y) { + return __y < __x; + } + friend bool operator<=(const StatsItem& __x, const StatsItem& __y) { + return !(__y < __x); + } + friend bool operator>=(const StatsItem& __x, const StatsItem& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::field_ref tag_vertices_ref() const& { + return {this->tag_vertices, __isset.tag_vertices}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref tag_vertices_ref() const&& { + return {std::move(this->tag_vertices), __isset.tag_vertices}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref tag_vertices_ref() & { + return {this->tag_vertices, __isset.tag_vertices}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref tag_vertices_ref() && { + return {std::move(this->tag_vertices), __isset.tag_vertices}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::field_ref edges_ref() const& { + return {this->edges, __isset.edges}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref edges_ref() const&& { + return {std::move(this->edges), __isset.edges}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref edges_ref() & { + return {this->edges, __isset.edges}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref edges_ref() && { + return {std::move(this->edges), __isset.edges}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref space_vertices_ref() const& { + return {this->space_vertices, __isset.space_vertices}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_vertices_ref() const&& { + return {std::move(this->space_vertices), __isset.space_vertices}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_vertices_ref() & { + return {this->space_vertices, __isset.space_vertices}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_vertices_ref() && { + return {std::move(this->space_vertices), __isset.space_vertices}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref space_edges_ref() const& { + return {this->space_edges, __isset.space_edges}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_edges_ref() const&& { + return {std::move(this->space_edges), __isset.space_edges}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_edges_ref() & { + return {this->space_edges, __isset.space_edges}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_edges_ref() && { + return {std::move(this->space_edges), __isset.space_edges}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template >> + FOLLY_ERASE ::apache::thrift::field_ref positive_part_correlativity_ref() const& { + return {this->positive_part_correlativity, __isset.positive_part_correlativity}; + } + + template >> + FOLLY_ERASE ::apache::thrift::field_ref positive_part_correlativity_ref() const&& { + return {std::move(this->positive_part_correlativity), __isset.positive_part_correlativity}; + } + + template >> + FOLLY_ERASE ::apache::thrift::field_ref positive_part_correlativity_ref() & { + return {this->positive_part_correlativity, __isset.positive_part_correlativity}; + } + + template >> + FOLLY_ERASE ::apache::thrift::field_ref positive_part_correlativity_ref() && { + return {std::move(this->positive_part_correlativity), __isset.positive_part_correlativity}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template >> + FOLLY_ERASE ::apache::thrift::field_ref negative_part_correlativity_ref() const& { + return {this->negative_part_correlativity, __isset.negative_part_correlativity}; + } + + template >> + FOLLY_ERASE ::apache::thrift::field_ref negative_part_correlativity_ref() const&& { + return {std::move(this->negative_part_correlativity), __isset.negative_part_correlativity}; + } + + template >> + FOLLY_ERASE ::apache::thrift::field_ref negative_part_correlativity_ref() & { + return {this->negative_part_correlativity, __isset.negative_part_correlativity}; + } + + template >> + FOLLY_ERASE ::apache::thrift::field_ref negative_part_correlativity_ref() && { + return {std::move(this->negative_part_correlativity), __isset.negative_part_correlativity}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref status_ref() const& { + return {this->status, __isset.status}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref status_ref() const&& { + return {std::move(this->status), __isset.status}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref status_ref() & { + return {this->status, __isset.status}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref status_ref() && { + return {std::move(this->status), __isset.status}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + const std::unordered_map<::std::string, int64_t>& get_tag_vertices() const&; + std::unordered_map<::std::string, int64_t> get_tag_vertices() &&; + + template > + std::unordered_map<::std::string, int64_t>& set_tag_vertices(T_StatsItem_tag_vertices_struct_setter&& tag_vertices_) { + tag_vertices = std::forward(tag_vertices_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.tag_vertices = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return tag_vertices; + } + const std::unordered_map<::std::string, int64_t>& get_edges() const&; + std::unordered_map<::std::string, int64_t> get_edges() &&; + + template > + std::unordered_map<::std::string, int64_t>& set_edges(T_StatsItem_edges_struct_setter&& edges_) { + edges = std::forward(edges_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.edges = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return edges; + } + + int64_t get_space_vertices() const { + return space_vertices; + } + + int64_t& set_space_vertices(int64_t space_vertices_) { + space_vertices = space_vertices_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.space_vertices = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return space_vertices; + } + + int64_t get_space_edges() const { + return space_edges; + } + + int64_t& set_space_edges(int64_t space_edges_) { + space_edges = space_edges_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.space_edges = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return space_edges; + } + const std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::meta::cpp2::Correlativity>>& get_positive_part_correlativity() const&; + std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::meta::cpp2::Correlativity>> get_positive_part_correlativity() &&; + + template >> + std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::meta::cpp2::Correlativity>>& set_positive_part_correlativity(T_StatsItem_positive_part_correlativity_struct_setter&& positive_part_correlativity_) { + positive_part_correlativity = std::forward(positive_part_correlativity_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.positive_part_correlativity = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return positive_part_correlativity; + } + const std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::meta::cpp2::Correlativity>>& get_negative_part_correlativity() const&; + std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::meta::cpp2::Correlativity>> get_negative_part_correlativity() &&; + + template >> + std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::meta::cpp2::Correlativity>>& set_negative_part_correlativity(T_StatsItem_negative_part_correlativity_struct_setter&& negative_part_correlativity_) { + negative_part_correlativity = std::forward(negative_part_correlativity_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.negative_part_correlativity = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return negative_part_correlativity; + } + + ::nebula::meta::cpp2::JobStatus get_status() const { + return status; + } + + ::nebula::meta::cpp2::JobStatus& set_status( ::nebula::meta::cpp2::JobStatus status_) { + status = status_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.status = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return status; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< StatsItem >; + friend void swap(StatsItem& a, StatsItem& b); +}; + +template +uint32_t StatsItem::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class CreateSpaceReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = CreateSpaceReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + CreateSpaceReq() : + if_not_exists(0) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + CreateSpaceReq(apache::thrift::FragileConstructor, ::nebula::meta::cpp2::SpaceDesc properties__arg, bool if_not_exists__arg); + + CreateSpaceReq(CreateSpaceReq&&) = default; + + CreateSpaceReq(const CreateSpaceReq&) = default; + + + CreateSpaceReq& operator=(CreateSpaceReq&&) = default; + + CreateSpaceReq& operator=(const CreateSpaceReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::meta::cpp2::SpaceDesc properties; + private: + bool if_not_exists; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool properties; + bool if_not_exists; + } __isset = {}; + bool operator==(const CreateSpaceReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const CreateSpaceReq& __x, const CreateSpaceReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const CreateSpaceReq& rhs) const; +#ifndef SWIG + friend bool operator>(const CreateSpaceReq& __x, const CreateSpaceReq& __y) { + return __y < __x; + } + friend bool operator<=(const CreateSpaceReq& __x, const CreateSpaceReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const CreateSpaceReq& __x, const CreateSpaceReq& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref properties_ref() const& { + return {this->properties, __isset.properties}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref properties_ref() const&& { + return {std::move(this->properties), __isset.properties}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref properties_ref() & { + return {this->properties, __isset.properties}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref properties_ref() && { + return {std::move(this->properties), __isset.properties}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref if_not_exists_ref() const& { + return {this->if_not_exists, __isset.if_not_exists}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref if_not_exists_ref() const&& { + return {std::move(this->if_not_exists), __isset.if_not_exists}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref if_not_exists_ref() & { + return {this->if_not_exists, __isset.if_not_exists}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref if_not_exists_ref() && { + return {std::move(this->if_not_exists), __isset.if_not_exists}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + const ::nebula::meta::cpp2::SpaceDesc& get_properties() const&; + ::nebula::meta::cpp2::SpaceDesc get_properties() &&; + + template + ::nebula::meta::cpp2::SpaceDesc& set_properties(T_CreateSpaceReq_properties_struct_setter&& properties_) { + properties = std::forward(properties_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.properties = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return properties; + } + + bool get_if_not_exists() const { + return if_not_exists; + } + + bool& set_if_not_exists(bool if_not_exists_) { + if_not_exists = if_not_exists_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.if_not_exists = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return if_not_exists; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< CreateSpaceReq >; + friend void swap(CreateSpaceReq& a, CreateSpaceReq& b); +}; + +template +uint32_t CreateSpaceReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class CreateSpaceAsReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = CreateSpaceAsReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + CreateSpaceAsReq() {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + CreateSpaceAsReq(apache::thrift::FragileConstructor, ::std::string old_space_name__arg, ::std::string new_space_name__arg); + + CreateSpaceAsReq(CreateSpaceAsReq&&) = default; + + CreateSpaceAsReq(const CreateSpaceAsReq&) = default; + + + CreateSpaceAsReq& operator=(CreateSpaceAsReq&&) = default; + + CreateSpaceAsReq& operator=(const CreateSpaceAsReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::std::string old_space_name; + private: + ::std::string new_space_name; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool old_space_name; + bool new_space_name; + } __isset = {}; + bool operator==(const CreateSpaceAsReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const CreateSpaceAsReq& __x, const CreateSpaceAsReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const CreateSpaceAsReq& rhs) const; +#ifndef SWIG + friend bool operator>(const CreateSpaceAsReq& __x, const CreateSpaceAsReq& __y) { + return __y < __x; + } + friend bool operator<=(const CreateSpaceAsReq& __x, const CreateSpaceAsReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const CreateSpaceAsReq& __x, const CreateSpaceAsReq& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref old_space_name_ref() const& { + return {this->old_space_name, __isset.old_space_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref old_space_name_ref() const&& { + return {std::move(this->old_space_name), __isset.old_space_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref old_space_name_ref() & { + return {this->old_space_name, __isset.old_space_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref old_space_name_ref() && { + return {std::move(this->old_space_name), __isset.old_space_name}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref new_space_name_ref() const& { + return {this->new_space_name, __isset.new_space_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref new_space_name_ref() const&& { + return {std::move(this->new_space_name), __isset.new_space_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref new_space_name_ref() & { + return {this->new_space_name, __isset.new_space_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref new_space_name_ref() && { + return {std::move(this->new_space_name), __isset.new_space_name}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + const ::std::string& get_old_space_name() const& { + return old_space_name; + } + + ::std::string get_old_space_name() && { + return std::move(old_space_name); + } + + template + ::std::string& set_old_space_name(T_CreateSpaceAsReq_old_space_name_struct_setter&& old_space_name_) { + old_space_name = std::forward(old_space_name_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.old_space_name = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return old_space_name; + } + + const ::std::string& get_new_space_name() const& { + return new_space_name; + } + + ::std::string get_new_space_name() && { + return std::move(new_space_name); + } + + template + ::std::string& set_new_space_name(T_CreateSpaceAsReq_new_space_name_struct_setter&& new_space_name_) { + new_space_name = std::forward(new_space_name_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.new_space_name = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return new_space_name; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< CreateSpaceAsReq >; + friend void swap(CreateSpaceAsReq& a, CreateSpaceAsReq& b); +}; + +template +uint32_t CreateSpaceAsReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class DropSpaceReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = DropSpaceReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + DropSpaceReq() : + if_exists(0) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + DropSpaceReq(apache::thrift::FragileConstructor, ::std::string space_name__arg, bool if_exists__arg); + + DropSpaceReq(DropSpaceReq&&) = default; + + DropSpaceReq(const DropSpaceReq&) = default; + + + DropSpaceReq& operator=(DropSpaceReq&&) = default; + + DropSpaceReq& operator=(const DropSpaceReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::std::string space_name; + private: + bool if_exists; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool space_name; + bool if_exists; + } __isset = {}; + bool operator==(const DropSpaceReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const DropSpaceReq& __x, const DropSpaceReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const DropSpaceReq& rhs) const; +#ifndef SWIG + friend bool operator>(const DropSpaceReq& __x, const DropSpaceReq& __y) { + return __y < __x; + } + friend bool operator<=(const DropSpaceReq& __x, const DropSpaceReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const DropSpaceReq& __x, const DropSpaceReq& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref space_name_ref() const& { + return {this->space_name, __isset.space_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_name_ref() const&& { + return {std::move(this->space_name), __isset.space_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_name_ref() & { + return {this->space_name, __isset.space_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_name_ref() && { + return {std::move(this->space_name), __isset.space_name}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref if_exists_ref() const& { + return {this->if_exists, __isset.if_exists}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref if_exists_ref() const&& { + return {std::move(this->if_exists), __isset.if_exists}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref if_exists_ref() & { + return {this->if_exists, __isset.if_exists}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref if_exists_ref() && { + return {std::move(this->if_exists), __isset.if_exists}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + const ::std::string& get_space_name() const& { + return space_name; + } + + ::std::string get_space_name() && { + return std::move(space_name); + } + + template + ::std::string& set_space_name(T_DropSpaceReq_space_name_struct_setter&& space_name_) { + space_name = std::forward(space_name_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.space_name = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return space_name; + } + + bool get_if_exists() const { + return if_exists; + } + + bool& set_if_exists(bool if_exists_) { + if_exists = if_exists_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.if_exists = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return if_exists; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< DropSpaceReq >; + friend void swap(DropSpaceReq& a, DropSpaceReq& b); +}; + +template +uint32_t DropSpaceReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class ListSpacesReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = ListSpacesReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + ListSpacesReq() {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + ListSpacesReq(apache::thrift::FragileConstructor); + + ListSpacesReq(ListSpacesReq&&) = default; + + ListSpacesReq(const ListSpacesReq&) = default; + + + ListSpacesReq& operator=(ListSpacesReq&&) = default; + + ListSpacesReq& operator=(const ListSpacesReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + bool operator==(const ListSpacesReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const ListSpacesReq& __x, const ListSpacesReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const ListSpacesReq& rhs) const; +#ifndef SWIG + friend bool operator>(const ListSpacesReq& __x, const ListSpacesReq& __y) { + return __y < __x; + } + friend bool operator<=(const ListSpacesReq& __x, const ListSpacesReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const ListSpacesReq& __x, const ListSpacesReq& __y) { + return !(__x < __y); + } +#endif + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< ListSpacesReq >; + friend void swap(ListSpacesReq& a, ListSpacesReq& b); +}; + +template +uint32_t ListSpacesReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class ListSpacesResp final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = ListSpacesResp; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + ListSpacesResp() : + code( ::nebula::cpp2::ErrorCode::SUCCEEDED) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + ListSpacesResp(apache::thrift::FragileConstructor, ::nebula::cpp2::ErrorCode code__arg, nebula::HostAddr leader__arg, ::std::vector< ::nebula::meta::cpp2::IdName> spaces__arg); + + ListSpacesResp(ListSpacesResp&&) = default; + + ListSpacesResp(const ListSpacesResp&) = default; + + + ListSpacesResp& operator=(ListSpacesResp&&) = default; + + ListSpacesResp& operator=(const ListSpacesResp&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::ErrorCode code; + private: + nebula::HostAddr leader; + private: + ::std::vector< ::nebula::meta::cpp2::IdName> spaces; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool code; + bool leader; + bool spaces; + } __isset = {}; + bool operator==(const ListSpacesResp& rhs) const; +#ifndef SWIG + friend bool operator!=(const ListSpacesResp& __x, const ListSpacesResp& __y) { + return !(__x == __y); + } +#endif + bool operator<(const ListSpacesResp& rhs) const; +#ifndef SWIG + friend bool operator>(const ListSpacesResp& __x, const ListSpacesResp& __y) { + return __y < __x; + } + friend bool operator<=(const ListSpacesResp& __x, const ListSpacesResp& __y) { + return !(__y < __x); + } + friend bool operator>=(const ListSpacesResp& __x, const ListSpacesResp& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() const& { + return {this->code, __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() const&& { + return {std::move(this->code), __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() & { + return {this->code, __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() && { + return {std::move(this->code), __isset.code}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() const& { + return {this->leader, __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() const&& { + return {std::move(this->leader), __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() & { + return {this->leader, __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() && { + return {std::move(this->leader), __isset.leader}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::field_ref spaces_ref() const& { + return {this->spaces, __isset.spaces}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref spaces_ref() const&& { + return {std::move(this->spaces), __isset.spaces}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref spaces_ref() & { + return {this->spaces, __isset.spaces}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref spaces_ref() && { + return {std::move(this->spaces), __isset.spaces}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::ErrorCode get_code() const { + return code; + } + + ::nebula::cpp2::ErrorCode& set_code( ::nebula::cpp2::ErrorCode code_) { + code = code_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.code = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return code; + } + const nebula::HostAddr& get_leader() const&; + nebula::HostAddr get_leader() &&; + + template + nebula::HostAddr& set_leader(T_ListSpacesResp_leader_struct_setter&& leader_) { + leader = std::forward(leader_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.leader = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return leader; + } + const ::std::vector< ::nebula::meta::cpp2::IdName>& get_spaces() const&; + ::std::vector< ::nebula::meta::cpp2::IdName> get_spaces() &&; + + template > + ::std::vector< ::nebula::meta::cpp2::IdName>& set_spaces(T_ListSpacesResp_spaces_struct_setter&& spaces_) { + spaces = std::forward(spaces_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.spaces = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return spaces; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< ListSpacesResp >; + friend void swap(ListSpacesResp& a, ListSpacesResp& b); +}; + +template +uint32_t ListSpacesResp::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class GetSpaceReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = GetSpaceReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + GetSpaceReq() {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + GetSpaceReq(apache::thrift::FragileConstructor, ::std::string space_name__arg); + + GetSpaceReq(GetSpaceReq&&) = default; + + GetSpaceReq(const GetSpaceReq&) = default; + + + GetSpaceReq& operator=(GetSpaceReq&&) = default; + + GetSpaceReq& operator=(const GetSpaceReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::std::string space_name; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool space_name; + } __isset = {}; + bool operator==(const GetSpaceReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const GetSpaceReq& __x, const GetSpaceReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const GetSpaceReq& rhs) const; +#ifndef SWIG + friend bool operator>(const GetSpaceReq& __x, const GetSpaceReq& __y) { + return __y < __x; + } + friend bool operator<=(const GetSpaceReq& __x, const GetSpaceReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const GetSpaceReq& __x, const GetSpaceReq& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref space_name_ref() const& { + return {this->space_name, __isset.space_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_name_ref() const&& { + return {std::move(this->space_name), __isset.space_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_name_ref() & { + return {this->space_name, __isset.space_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_name_ref() && { + return {std::move(this->space_name), __isset.space_name}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + const ::std::string& get_space_name() const& { + return space_name; + } + + ::std::string get_space_name() && { + return std::move(space_name); + } + + template + ::std::string& set_space_name(T_GetSpaceReq_space_name_struct_setter&& space_name_) { + space_name = std::forward(space_name_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.space_name = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return space_name; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< GetSpaceReq >; + friend void swap(GetSpaceReq& a, GetSpaceReq& b); +}; + +template +uint32_t GetSpaceReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class GetSpaceResp final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = GetSpaceResp; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + GetSpaceResp() : + code( ::nebula::cpp2::ErrorCode::SUCCEEDED) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + GetSpaceResp(apache::thrift::FragileConstructor, ::nebula::cpp2::ErrorCode code__arg, nebula::HostAddr leader__arg, ::nebula::meta::cpp2::SpaceItem item__arg); + + GetSpaceResp(GetSpaceResp&&) = default; + + GetSpaceResp(const GetSpaceResp&) = default; + + + GetSpaceResp& operator=(GetSpaceResp&&) = default; + + GetSpaceResp& operator=(const GetSpaceResp&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::ErrorCode code; + private: + nebula::HostAddr leader; + private: + ::nebula::meta::cpp2::SpaceItem item; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool code; + bool leader; + bool item; + } __isset = {}; + bool operator==(const GetSpaceResp& rhs) const; +#ifndef SWIG + friend bool operator!=(const GetSpaceResp& __x, const GetSpaceResp& __y) { + return !(__x == __y); + } +#endif + bool operator<(const GetSpaceResp& rhs) const; +#ifndef SWIG + friend bool operator>(const GetSpaceResp& __x, const GetSpaceResp& __y) { + return __y < __x; + } + friend bool operator<=(const GetSpaceResp& __x, const GetSpaceResp& __y) { + return !(__y < __x); + } + friend bool operator>=(const GetSpaceResp& __x, const GetSpaceResp& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() const& { + return {this->code, __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() const&& { + return {std::move(this->code), __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() & { + return {this->code, __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() && { + return {std::move(this->code), __isset.code}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() const& { + return {this->leader, __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() const&& { + return {std::move(this->leader), __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() & { + return {this->leader, __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() && { + return {std::move(this->leader), __isset.leader}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref item_ref() const& { + return {this->item, __isset.item}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref item_ref() const&& { + return {std::move(this->item), __isset.item}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref item_ref() & { + return {this->item, __isset.item}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref item_ref() && { + return {std::move(this->item), __isset.item}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::ErrorCode get_code() const { + return code; + } + + ::nebula::cpp2::ErrorCode& set_code( ::nebula::cpp2::ErrorCode code_) { + code = code_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.code = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return code; + } + const nebula::HostAddr& get_leader() const&; + nebula::HostAddr get_leader() &&; + + template + nebula::HostAddr& set_leader(T_GetSpaceResp_leader_struct_setter&& leader_) { + leader = std::forward(leader_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.leader = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return leader; + } + const ::nebula::meta::cpp2::SpaceItem& get_item() const&; + ::nebula::meta::cpp2::SpaceItem get_item() &&; + + template + ::nebula::meta::cpp2::SpaceItem& set_item(T_GetSpaceResp_item_struct_setter&& item_) { + item = std::forward(item_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.item = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return item; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< GetSpaceResp >; + friend void swap(GetSpaceResp& a, GetSpaceResp& b); +}; + +template +uint32_t GetSpaceResp::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class CreateTagReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = CreateTagReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + CreateTagReq() : + space_id(0), + if_not_exists(0) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + CreateTagReq(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, ::std::string tag_name__arg, ::nebula::meta::cpp2::Schema schema__arg, bool if_not_exists__arg); + + CreateTagReq(CreateTagReq&&) = default; + + CreateTagReq(const CreateTagReq&) = default; + + + CreateTagReq& operator=(CreateTagReq&&) = default; + + CreateTagReq& operator=(const CreateTagReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::GraphSpaceID space_id; + private: + ::std::string tag_name; + private: + ::nebula::meta::cpp2::Schema schema; + private: + bool if_not_exists; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool space_id; + bool tag_name; + bool schema; + bool if_not_exists; + } __isset = {}; + bool operator==(const CreateTagReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const CreateTagReq& __x, const CreateTagReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const CreateTagReq& rhs) const; +#ifndef SWIG + friend bool operator>(const CreateTagReq& __x, const CreateTagReq& __y) { + return __y < __x; + } + friend bool operator<=(const CreateTagReq& __x, const CreateTagReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const CreateTagReq& __x, const CreateTagReq& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const& { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const&& { + return {std::move(this->space_id), __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() & { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() && { + return {std::move(this->space_id), __isset.space_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref tag_name_ref() const& { + return {this->tag_name, __isset.tag_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref tag_name_ref() const&& { + return {std::move(this->tag_name), __isset.tag_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref tag_name_ref() & { + return {this->tag_name, __isset.tag_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref tag_name_ref() && { + return {std::move(this->tag_name), __isset.tag_name}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref schema_ref() const& { + return {this->schema, __isset.schema}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref schema_ref() const&& { + return {std::move(this->schema), __isset.schema}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref schema_ref() & { + return {this->schema, __isset.schema}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref schema_ref() && { + return {std::move(this->schema), __isset.schema}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref if_not_exists_ref() const& { + return {this->if_not_exists, __isset.if_not_exists}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref if_not_exists_ref() const&& { + return {std::move(this->if_not_exists), __isset.if_not_exists}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref if_not_exists_ref() & { + return {this->if_not_exists, __isset.if_not_exists}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref if_not_exists_ref() && { + return {std::move(this->if_not_exists), __isset.if_not_exists}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::GraphSpaceID get_space_id() const { + return space_id; + } + + ::nebula::cpp2::GraphSpaceID& set_space_id( ::nebula::cpp2::GraphSpaceID space_id_) { + space_id = space_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.space_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return space_id; + } + + const ::std::string& get_tag_name() const& { + return tag_name; + } + + ::std::string get_tag_name() && { + return std::move(tag_name); + } + + template + ::std::string& set_tag_name(T_CreateTagReq_tag_name_struct_setter&& tag_name_) { + tag_name = std::forward(tag_name_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.tag_name = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return tag_name; + } + const ::nebula::meta::cpp2::Schema& get_schema() const&; + ::nebula::meta::cpp2::Schema get_schema() &&; + + template + ::nebula::meta::cpp2::Schema& set_schema(T_CreateTagReq_schema_struct_setter&& schema_) { + schema = std::forward(schema_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.schema = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return schema; + } + + bool get_if_not_exists() const { + return if_not_exists; + } + + bool& set_if_not_exists(bool if_not_exists_) { + if_not_exists = if_not_exists_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.if_not_exists = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return if_not_exists; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< CreateTagReq >; + friend void swap(CreateTagReq& a, CreateTagReq& b); +}; + +template +uint32_t CreateTagReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class AlterTagReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = AlterTagReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + AlterTagReq() : + space_id(0) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + AlterTagReq(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, ::std::string tag_name__arg, ::std::vector< ::nebula::meta::cpp2::AlterSchemaItem> tag_items__arg, ::nebula::meta::cpp2::SchemaProp schema_prop__arg); + + AlterTagReq(AlterTagReq&&) = default; + + AlterTagReq(const AlterTagReq&) = default; + + + AlterTagReq& operator=(AlterTagReq&&) = default; + + AlterTagReq& operator=(const AlterTagReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::GraphSpaceID space_id; + private: + ::std::string tag_name; + private: + ::std::vector< ::nebula::meta::cpp2::AlterSchemaItem> tag_items; + private: + ::nebula::meta::cpp2::SchemaProp schema_prop; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool space_id; + bool tag_name; + bool tag_items; + bool schema_prop; + } __isset = {}; + bool operator==(const AlterTagReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const AlterTagReq& __x, const AlterTagReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const AlterTagReq& rhs) const; +#ifndef SWIG + friend bool operator>(const AlterTagReq& __x, const AlterTagReq& __y) { + return __y < __x; + } + friend bool operator<=(const AlterTagReq& __x, const AlterTagReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const AlterTagReq& __x, const AlterTagReq& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const& { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const&& { + return {std::move(this->space_id), __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() & { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() && { + return {std::move(this->space_id), __isset.space_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref tag_name_ref() const& { + return {this->tag_name, __isset.tag_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref tag_name_ref() const&& { + return {std::move(this->tag_name), __isset.tag_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref tag_name_ref() & { + return {this->tag_name, __isset.tag_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref tag_name_ref() && { + return {std::move(this->tag_name), __isset.tag_name}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::field_ref tag_items_ref() const& { + return {this->tag_items, __isset.tag_items}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref tag_items_ref() const&& { + return {std::move(this->tag_items), __isset.tag_items}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref tag_items_ref() & { + return {this->tag_items, __isset.tag_items}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref tag_items_ref() && { + return {std::move(this->tag_items), __isset.tag_items}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref schema_prop_ref() const& { + return {this->schema_prop, __isset.schema_prop}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref schema_prop_ref() const&& { + return {std::move(this->schema_prop), __isset.schema_prop}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref schema_prop_ref() & { + return {this->schema_prop, __isset.schema_prop}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref schema_prop_ref() && { + return {std::move(this->schema_prop), __isset.schema_prop}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::GraphSpaceID get_space_id() const { + return space_id; + } + + ::nebula::cpp2::GraphSpaceID& set_space_id( ::nebula::cpp2::GraphSpaceID space_id_) { + space_id = space_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.space_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return space_id; + } + + const ::std::string& get_tag_name() const& { + return tag_name; + } + + ::std::string get_tag_name() && { + return std::move(tag_name); + } + + template + ::std::string& set_tag_name(T_AlterTagReq_tag_name_struct_setter&& tag_name_) { + tag_name = std::forward(tag_name_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.tag_name = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return tag_name; + } + const ::std::vector< ::nebula::meta::cpp2::AlterSchemaItem>& get_tag_items() const&; + ::std::vector< ::nebula::meta::cpp2::AlterSchemaItem> get_tag_items() &&; + + template > + ::std::vector< ::nebula::meta::cpp2::AlterSchemaItem>& set_tag_items(T_AlterTagReq_tag_items_struct_setter&& tag_items_) { + tag_items = std::forward(tag_items_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.tag_items = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return tag_items; + } + const ::nebula::meta::cpp2::SchemaProp& get_schema_prop() const&; + ::nebula::meta::cpp2::SchemaProp get_schema_prop() &&; + + template + ::nebula::meta::cpp2::SchemaProp& set_schema_prop(T_AlterTagReq_schema_prop_struct_setter&& schema_prop_) { + schema_prop = std::forward(schema_prop_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.schema_prop = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return schema_prop; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< AlterTagReq >; + friend void swap(AlterTagReq& a, AlterTagReq& b); +}; + +template +uint32_t AlterTagReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class DropTagReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = DropTagReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + DropTagReq() : + space_id(0), + if_exists(0) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + DropTagReq(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, ::std::string tag_name__arg, bool if_exists__arg); + + DropTagReq(DropTagReq&&) = default; + + DropTagReq(const DropTagReq&) = default; + + + DropTagReq& operator=(DropTagReq&&) = default; + + DropTagReq& operator=(const DropTagReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::GraphSpaceID space_id; + private: + ::std::string tag_name; + private: + bool if_exists; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool space_id; + bool tag_name; + bool if_exists; + } __isset = {}; + bool operator==(const DropTagReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const DropTagReq& __x, const DropTagReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const DropTagReq& rhs) const; +#ifndef SWIG + friend bool operator>(const DropTagReq& __x, const DropTagReq& __y) { + return __y < __x; + } + friend bool operator<=(const DropTagReq& __x, const DropTagReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const DropTagReq& __x, const DropTagReq& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const& { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const&& { + return {std::move(this->space_id), __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() & { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() && { + return {std::move(this->space_id), __isset.space_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref tag_name_ref() const& { + return {this->tag_name, __isset.tag_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref tag_name_ref() const&& { + return {std::move(this->tag_name), __isset.tag_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref tag_name_ref() & { + return {this->tag_name, __isset.tag_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref tag_name_ref() && { + return {std::move(this->tag_name), __isset.tag_name}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref if_exists_ref() const& { + return {this->if_exists, __isset.if_exists}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref if_exists_ref() const&& { + return {std::move(this->if_exists), __isset.if_exists}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref if_exists_ref() & { + return {this->if_exists, __isset.if_exists}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref if_exists_ref() && { + return {std::move(this->if_exists), __isset.if_exists}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::GraphSpaceID get_space_id() const { + return space_id; + } + + ::nebula::cpp2::GraphSpaceID& set_space_id( ::nebula::cpp2::GraphSpaceID space_id_) { + space_id = space_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.space_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return space_id; + } + + const ::std::string& get_tag_name() const& { + return tag_name; + } + + ::std::string get_tag_name() && { + return std::move(tag_name); + } + + template + ::std::string& set_tag_name(T_DropTagReq_tag_name_struct_setter&& tag_name_) { + tag_name = std::forward(tag_name_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.tag_name = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return tag_name; + } + + bool get_if_exists() const { + return if_exists; + } + + bool& set_if_exists(bool if_exists_) { + if_exists = if_exists_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.if_exists = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return if_exists; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< DropTagReq >; + friend void swap(DropTagReq& a, DropTagReq& b); +}; + +template +uint32_t DropTagReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class ListTagsReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = ListTagsReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + ListTagsReq() : + space_id(0) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + ListTagsReq(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg); + + ListTagsReq(ListTagsReq&&) = default; + + ListTagsReq(const ListTagsReq&) = default; + + + ListTagsReq& operator=(ListTagsReq&&) = default; + + ListTagsReq& operator=(const ListTagsReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::GraphSpaceID space_id; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool space_id; + } __isset = {}; + bool operator==(const ListTagsReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const ListTagsReq& __x, const ListTagsReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const ListTagsReq& rhs) const; +#ifndef SWIG + friend bool operator>(const ListTagsReq& __x, const ListTagsReq& __y) { + return __y < __x; + } + friend bool operator<=(const ListTagsReq& __x, const ListTagsReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const ListTagsReq& __x, const ListTagsReq& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const& { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const&& { + return {std::move(this->space_id), __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() & { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() && { + return {std::move(this->space_id), __isset.space_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::GraphSpaceID get_space_id() const { + return space_id; + } + + ::nebula::cpp2::GraphSpaceID& set_space_id( ::nebula::cpp2::GraphSpaceID space_id_) { + space_id = space_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.space_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return space_id; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< ListTagsReq >; + friend void swap(ListTagsReq& a, ListTagsReq& b); +}; + +template +uint32_t ListTagsReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class ListTagsResp final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = ListTagsResp; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + ListTagsResp() : + code( ::nebula::cpp2::ErrorCode::SUCCEEDED) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + ListTagsResp(apache::thrift::FragileConstructor, ::nebula::cpp2::ErrorCode code__arg, nebula::HostAddr leader__arg, ::std::vector< ::nebula::meta::cpp2::TagItem> tags__arg); + + ListTagsResp(ListTagsResp&&) = default; + + ListTagsResp(const ListTagsResp&) = default; + + + ListTagsResp& operator=(ListTagsResp&&) = default; + + ListTagsResp& operator=(const ListTagsResp&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::ErrorCode code; + private: + nebula::HostAddr leader; + private: + ::std::vector< ::nebula::meta::cpp2::TagItem> tags; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool code; + bool leader; + bool tags; + } __isset = {}; + bool operator==(const ListTagsResp& rhs) const; +#ifndef SWIG + friend bool operator!=(const ListTagsResp& __x, const ListTagsResp& __y) { + return !(__x == __y); + } +#endif + bool operator<(const ListTagsResp& rhs) const; +#ifndef SWIG + friend bool operator>(const ListTagsResp& __x, const ListTagsResp& __y) { + return __y < __x; + } + friend bool operator<=(const ListTagsResp& __x, const ListTagsResp& __y) { + return !(__y < __x); + } + friend bool operator>=(const ListTagsResp& __x, const ListTagsResp& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() const& { + return {this->code, __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() const&& { + return {std::move(this->code), __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() & { + return {this->code, __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() && { + return {std::move(this->code), __isset.code}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() const& { + return {this->leader, __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() const&& { + return {std::move(this->leader), __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() & { + return {this->leader, __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() && { + return {std::move(this->leader), __isset.leader}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::field_ref tags_ref() const& { + return {this->tags, __isset.tags}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref tags_ref() const&& { + return {std::move(this->tags), __isset.tags}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref tags_ref() & { + return {this->tags, __isset.tags}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref tags_ref() && { + return {std::move(this->tags), __isset.tags}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::ErrorCode get_code() const { + return code; + } + + ::nebula::cpp2::ErrorCode& set_code( ::nebula::cpp2::ErrorCode code_) { + code = code_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.code = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return code; + } + const nebula::HostAddr& get_leader() const&; + nebula::HostAddr get_leader() &&; + + template + nebula::HostAddr& set_leader(T_ListTagsResp_leader_struct_setter&& leader_) { + leader = std::forward(leader_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.leader = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return leader; + } + const ::std::vector< ::nebula::meta::cpp2::TagItem>& get_tags() const&; + ::std::vector< ::nebula::meta::cpp2::TagItem> get_tags() &&; + + template > + ::std::vector< ::nebula::meta::cpp2::TagItem>& set_tags(T_ListTagsResp_tags_struct_setter&& tags_) { + tags = std::forward(tags_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.tags = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return tags; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< ListTagsResp >; + friend void swap(ListTagsResp& a, ListTagsResp& b); +}; + +template +uint32_t ListTagsResp::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class GetTagReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = GetTagReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + GetTagReq() : + space_id(0), + version(0) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + GetTagReq(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, ::std::string tag_name__arg, ::nebula::meta::cpp2::SchemaVer version__arg); + + GetTagReq(GetTagReq&&) = default; + + GetTagReq(const GetTagReq&) = default; + + + GetTagReq& operator=(GetTagReq&&) = default; + + GetTagReq& operator=(const GetTagReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::GraphSpaceID space_id; + private: + ::std::string tag_name; + private: + ::nebula::meta::cpp2::SchemaVer version; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool space_id; + bool tag_name; + bool version; + } __isset = {}; + bool operator==(const GetTagReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const GetTagReq& __x, const GetTagReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const GetTagReq& rhs) const; +#ifndef SWIG + friend bool operator>(const GetTagReq& __x, const GetTagReq& __y) { + return __y < __x; + } + friend bool operator<=(const GetTagReq& __x, const GetTagReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const GetTagReq& __x, const GetTagReq& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const& { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const&& { + return {std::move(this->space_id), __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() & { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() && { + return {std::move(this->space_id), __isset.space_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref tag_name_ref() const& { + return {this->tag_name, __isset.tag_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref tag_name_ref() const&& { + return {std::move(this->tag_name), __isset.tag_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref tag_name_ref() & { + return {this->tag_name, __isset.tag_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref tag_name_ref() && { + return {std::move(this->tag_name), __isset.tag_name}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref version_ref() const& { + return {this->version, __isset.version}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref version_ref() const&& { + return {std::move(this->version), __isset.version}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref version_ref() & { + return {this->version, __isset.version}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref version_ref() && { + return {std::move(this->version), __isset.version}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::GraphSpaceID get_space_id() const { + return space_id; + } + + ::nebula::cpp2::GraphSpaceID& set_space_id( ::nebula::cpp2::GraphSpaceID space_id_) { + space_id = space_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.space_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return space_id; + } + + const ::std::string& get_tag_name() const& { + return tag_name; + } + + ::std::string get_tag_name() && { + return std::move(tag_name); + } + + template + ::std::string& set_tag_name(T_GetTagReq_tag_name_struct_setter&& tag_name_) { + tag_name = std::forward(tag_name_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.tag_name = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return tag_name; + } + + ::nebula::meta::cpp2::SchemaVer get_version() const { + return version; + } + + ::nebula::meta::cpp2::SchemaVer& set_version( ::nebula::meta::cpp2::SchemaVer version_) { + version = version_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.version = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return version; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< GetTagReq >; + friend void swap(GetTagReq& a, GetTagReq& b); +}; + +template +uint32_t GetTagReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class GetTagResp final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = GetTagResp; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + GetTagResp() : + code( ::nebula::cpp2::ErrorCode::SUCCEEDED) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + GetTagResp(apache::thrift::FragileConstructor, ::nebula::cpp2::ErrorCode code__arg, nebula::HostAddr leader__arg, ::nebula::meta::cpp2::Schema schema__arg); + + GetTagResp(GetTagResp&&) = default; + + GetTagResp(const GetTagResp&) = default; + + + GetTagResp& operator=(GetTagResp&&) = default; + + GetTagResp& operator=(const GetTagResp&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::ErrorCode code; + private: + nebula::HostAddr leader; + private: + ::nebula::meta::cpp2::Schema schema; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool code; + bool leader; + bool schema; + } __isset = {}; + bool operator==(const GetTagResp& rhs) const; +#ifndef SWIG + friend bool operator!=(const GetTagResp& __x, const GetTagResp& __y) { + return !(__x == __y); + } +#endif + bool operator<(const GetTagResp& rhs) const; +#ifndef SWIG + friend bool operator>(const GetTagResp& __x, const GetTagResp& __y) { + return __y < __x; + } + friend bool operator<=(const GetTagResp& __x, const GetTagResp& __y) { + return !(__y < __x); + } + friend bool operator>=(const GetTagResp& __x, const GetTagResp& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() const& { + return {this->code, __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() const&& { + return {std::move(this->code), __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() & { + return {this->code, __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() && { + return {std::move(this->code), __isset.code}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() const& { + return {this->leader, __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() const&& { + return {std::move(this->leader), __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() & { + return {this->leader, __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() && { + return {std::move(this->leader), __isset.leader}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref schema_ref() const& { + return {this->schema, __isset.schema}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref schema_ref() const&& { + return {std::move(this->schema), __isset.schema}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref schema_ref() & { + return {this->schema, __isset.schema}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref schema_ref() && { + return {std::move(this->schema), __isset.schema}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::ErrorCode get_code() const { + return code; + } + + ::nebula::cpp2::ErrorCode& set_code( ::nebula::cpp2::ErrorCode code_) { + code = code_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.code = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return code; + } + const nebula::HostAddr& get_leader() const&; + nebula::HostAddr get_leader() &&; + + template + nebula::HostAddr& set_leader(T_GetTagResp_leader_struct_setter&& leader_) { + leader = std::forward(leader_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.leader = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return leader; + } + const ::nebula::meta::cpp2::Schema& get_schema() const&; + ::nebula::meta::cpp2::Schema get_schema() &&; + + template + ::nebula::meta::cpp2::Schema& set_schema(T_GetTagResp_schema_struct_setter&& schema_) { + schema = std::forward(schema_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.schema = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return schema; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< GetTagResp >; + friend void swap(GetTagResp& a, GetTagResp& b); +}; + +template +uint32_t GetTagResp::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class CreateEdgeReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = CreateEdgeReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + CreateEdgeReq() : + space_id(0), + if_not_exists(0) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + CreateEdgeReq(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, ::std::string edge_name__arg, ::nebula::meta::cpp2::Schema schema__arg, bool if_not_exists__arg); + + CreateEdgeReq(CreateEdgeReq&&) = default; + + CreateEdgeReq(const CreateEdgeReq&) = default; + + + CreateEdgeReq& operator=(CreateEdgeReq&&) = default; + + CreateEdgeReq& operator=(const CreateEdgeReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::GraphSpaceID space_id; + private: + ::std::string edge_name; + private: + ::nebula::meta::cpp2::Schema schema; + private: + bool if_not_exists; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool space_id; + bool edge_name; + bool schema; + bool if_not_exists; + } __isset = {}; + bool operator==(const CreateEdgeReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const CreateEdgeReq& __x, const CreateEdgeReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const CreateEdgeReq& rhs) const; +#ifndef SWIG + friend bool operator>(const CreateEdgeReq& __x, const CreateEdgeReq& __y) { + return __y < __x; + } + friend bool operator<=(const CreateEdgeReq& __x, const CreateEdgeReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const CreateEdgeReq& __x, const CreateEdgeReq& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const& { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const&& { + return {std::move(this->space_id), __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() & { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() && { + return {std::move(this->space_id), __isset.space_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref edge_name_ref() const& { + return {this->edge_name, __isset.edge_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref edge_name_ref() const&& { + return {std::move(this->edge_name), __isset.edge_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref edge_name_ref() & { + return {this->edge_name, __isset.edge_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref edge_name_ref() && { + return {std::move(this->edge_name), __isset.edge_name}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref schema_ref() const& { + return {this->schema, __isset.schema}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref schema_ref() const&& { + return {std::move(this->schema), __isset.schema}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref schema_ref() & { + return {this->schema, __isset.schema}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref schema_ref() && { + return {std::move(this->schema), __isset.schema}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref if_not_exists_ref() const& { + return {this->if_not_exists, __isset.if_not_exists}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref if_not_exists_ref() const&& { + return {std::move(this->if_not_exists), __isset.if_not_exists}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref if_not_exists_ref() & { + return {this->if_not_exists, __isset.if_not_exists}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref if_not_exists_ref() && { + return {std::move(this->if_not_exists), __isset.if_not_exists}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::GraphSpaceID get_space_id() const { + return space_id; + } + + ::nebula::cpp2::GraphSpaceID& set_space_id( ::nebula::cpp2::GraphSpaceID space_id_) { + space_id = space_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.space_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return space_id; + } + + const ::std::string& get_edge_name() const& { + return edge_name; + } + + ::std::string get_edge_name() && { + return std::move(edge_name); + } + + template + ::std::string& set_edge_name(T_CreateEdgeReq_edge_name_struct_setter&& edge_name_) { + edge_name = std::forward(edge_name_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.edge_name = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return edge_name; + } + const ::nebula::meta::cpp2::Schema& get_schema() const&; + ::nebula::meta::cpp2::Schema get_schema() &&; + + template + ::nebula::meta::cpp2::Schema& set_schema(T_CreateEdgeReq_schema_struct_setter&& schema_) { + schema = std::forward(schema_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.schema = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return schema; + } + + bool get_if_not_exists() const { + return if_not_exists; + } + + bool& set_if_not_exists(bool if_not_exists_) { + if_not_exists = if_not_exists_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.if_not_exists = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return if_not_exists; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< CreateEdgeReq >; + friend void swap(CreateEdgeReq& a, CreateEdgeReq& b); +}; + +template +uint32_t CreateEdgeReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class AlterEdgeReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = AlterEdgeReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + AlterEdgeReq() : + space_id(0) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + AlterEdgeReq(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, ::std::string edge_name__arg, ::std::vector< ::nebula::meta::cpp2::AlterSchemaItem> edge_items__arg, ::nebula::meta::cpp2::SchemaProp schema_prop__arg); + + AlterEdgeReq(AlterEdgeReq&&) = default; + + AlterEdgeReq(const AlterEdgeReq&) = default; + + + AlterEdgeReq& operator=(AlterEdgeReq&&) = default; + + AlterEdgeReq& operator=(const AlterEdgeReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::GraphSpaceID space_id; + private: + ::std::string edge_name; + private: + ::std::vector< ::nebula::meta::cpp2::AlterSchemaItem> edge_items; + private: + ::nebula::meta::cpp2::SchemaProp schema_prop; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool space_id; + bool edge_name; + bool edge_items; + bool schema_prop; + } __isset = {}; + bool operator==(const AlterEdgeReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const AlterEdgeReq& __x, const AlterEdgeReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const AlterEdgeReq& rhs) const; +#ifndef SWIG + friend bool operator>(const AlterEdgeReq& __x, const AlterEdgeReq& __y) { + return __y < __x; + } + friend bool operator<=(const AlterEdgeReq& __x, const AlterEdgeReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const AlterEdgeReq& __x, const AlterEdgeReq& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const& { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const&& { + return {std::move(this->space_id), __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() & { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() && { + return {std::move(this->space_id), __isset.space_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref edge_name_ref() const& { + return {this->edge_name, __isset.edge_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref edge_name_ref() const&& { + return {std::move(this->edge_name), __isset.edge_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref edge_name_ref() & { + return {this->edge_name, __isset.edge_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref edge_name_ref() && { + return {std::move(this->edge_name), __isset.edge_name}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::field_ref edge_items_ref() const& { + return {this->edge_items, __isset.edge_items}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref edge_items_ref() const&& { + return {std::move(this->edge_items), __isset.edge_items}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref edge_items_ref() & { + return {this->edge_items, __isset.edge_items}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref edge_items_ref() && { + return {std::move(this->edge_items), __isset.edge_items}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref schema_prop_ref() const& { + return {this->schema_prop, __isset.schema_prop}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref schema_prop_ref() const&& { + return {std::move(this->schema_prop), __isset.schema_prop}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref schema_prop_ref() & { + return {this->schema_prop, __isset.schema_prop}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref schema_prop_ref() && { + return {std::move(this->schema_prop), __isset.schema_prop}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::GraphSpaceID get_space_id() const { + return space_id; + } + + ::nebula::cpp2::GraphSpaceID& set_space_id( ::nebula::cpp2::GraphSpaceID space_id_) { + space_id = space_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.space_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return space_id; + } + + const ::std::string& get_edge_name() const& { + return edge_name; + } + + ::std::string get_edge_name() && { + return std::move(edge_name); + } + + template + ::std::string& set_edge_name(T_AlterEdgeReq_edge_name_struct_setter&& edge_name_) { + edge_name = std::forward(edge_name_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.edge_name = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return edge_name; + } + const ::std::vector< ::nebula::meta::cpp2::AlterSchemaItem>& get_edge_items() const&; + ::std::vector< ::nebula::meta::cpp2::AlterSchemaItem> get_edge_items() &&; + + template > + ::std::vector< ::nebula::meta::cpp2::AlterSchemaItem>& set_edge_items(T_AlterEdgeReq_edge_items_struct_setter&& edge_items_) { + edge_items = std::forward(edge_items_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.edge_items = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return edge_items; + } + const ::nebula::meta::cpp2::SchemaProp& get_schema_prop() const&; + ::nebula::meta::cpp2::SchemaProp get_schema_prop() &&; + + template + ::nebula::meta::cpp2::SchemaProp& set_schema_prop(T_AlterEdgeReq_schema_prop_struct_setter&& schema_prop_) { + schema_prop = std::forward(schema_prop_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.schema_prop = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return schema_prop; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< AlterEdgeReq >; + friend void swap(AlterEdgeReq& a, AlterEdgeReq& b); +}; + +template +uint32_t AlterEdgeReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class GetEdgeReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = GetEdgeReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + GetEdgeReq() : + space_id(0), + version(0) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + GetEdgeReq(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, ::std::string edge_name__arg, ::nebula::meta::cpp2::SchemaVer version__arg); + + GetEdgeReq(GetEdgeReq&&) = default; + + GetEdgeReq(const GetEdgeReq&) = default; + + + GetEdgeReq& operator=(GetEdgeReq&&) = default; + + GetEdgeReq& operator=(const GetEdgeReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::GraphSpaceID space_id; + private: + ::std::string edge_name; + private: + ::nebula::meta::cpp2::SchemaVer version; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool space_id; + bool edge_name; + bool version; + } __isset = {}; + bool operator==(const GetEdgeReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const GetEdgeReq& __x, const GetEdgeReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const GetEdgeReq& rhs) const; +#ifndef SWIG + friend bool operator>(const GetEdgeReq& __x, const GetEdgeReq& __y) { + return __y < __x; + } + friend bool operator<=(const GetEdgeReq& __x, const GetEdgeReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const GetEdgeReq& __x, const GetEdgeReq& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const& { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const&& { + return {std::move(this->space_id), __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() & { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() && { + return {std::move(this->space_id), __isset.space_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref edge_name_ref() const& { + return {this->edge_name, __isset.edge_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref edge_name_ref() const&& { + return {std::move(this->edge_name), __isset.edge_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref edge_name_ref() & { + return {this->edge_name, __isset.edge_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref edge_name_ref() && { + return {std::move(this->edge_name), __isset.edge_name}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref version_ref() const& { + return {this->version, __isset.version}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref version_ref() const&& { + return {std::move(this->version), __isset.version}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref version_ref() & { + return {this->version, __isset.version}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref version_ref() && { + return {std::move(this->version), __isset.version}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::GraphSpaceID get_space_id() const { + return space_id; + } + + ::nebula::cpp2::GraphSpaceID& set_space_id( ::nebula::cpp2::GraphSpaceID space_id_) { + space_id = space_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.space_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return space_id; + } + + const ::std::string& get_edge_name() const& { + return edge_name; + } + + ::std::string get_edge_name() && { + return std::move(edge_name); + } + + template + ::std::string& set_edge_name(T_GetEdgeReq_edge_name_struct_setter&& edge_name_) { + edge_name = std::forward(edge_name_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.edge_name = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return edge_name; + } + + ::nebula::meta::cpp2::SchemaVer get_version() const { + return version; + } + + ::nebula::meta::cpp2::SchemaVer& set_version( ::nebula::meta::cpp2::SchemaVer version_) { + version = version_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.version = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return version; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< GetEdgeReq >; + friend void swap(GetEdgeReq& a, GetEdgeReq& b); +}; + +template +uint32_t GetEdgeReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class GetEdgeResp final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = GetEdgeResp; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + GetEdgeResp() : + code( ::nebula::cpp2::ErrorCode::SUCCEEDED) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + GetEdgeResp(apache::thrift::FragileConstructor, ::nebula::cpp2::ErrorCode code__arg, nebula::HostAddr leader__arg, ::nebula::meta::cpp2::Schema schema__arg); + + GetEdgeResp(GetEdgeResp&&) = default; + + GetEdgeResp(const GetEdgeResp&) = default; + + + GetEdgeResp& operator=(GetEdgeResp&&) = default; + + GetEdgeResp& operator=(const GetEdgeResp&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::ErrorCode code; + private: + nebula::HostAddr leader; + private: + ::nebula::meta::cpp2::Schema schema; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool code; + bool leader; + bool schema; + } __isset = {}; + bool operator==(const GetEdgeResp& rhs) const; +#ifndef SWIG + friend bool operator!=(const GetEdgeResp& __x, const GetEdgeResp& __y) { + return !(__x == __y); + } +#endif + bool operator<(const GetEdgeResp& rhs) const; +#ifndef SWIG + friend bool operator>(const GetEdgeResp& __x, const GetEdgeResp& __y) { + return __y < __x; + } + friend bool operator<=(const GetEdgeResp& __x, const GetEdgeResp& __y) { + return !(__y < __x); + } + friend bool operator>=(const GetEdgeResp& __x, const GetEdgeResp& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() const& { + return {this->code, __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() const&& { + return {std::move(this->code), __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() & { + return {this->code, __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() && { + return {std::move(this->code), __isset.code}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() const& { + return {this->leader, __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() const&& { + return {std::move(this->leader), __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() & { + return {this->leader, __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() && { + return {std::move(this->leader), __isset.leader}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref schema_ref() const& { + return {this->schema, __isset.schema}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref schema_ref() const&& { + return {std::move(this->schema), __isset.schema}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref schema_ref() & { + return {this->schema, __isset.schema}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref schema_ref() && { + return {std::move(this->schema), __isset.schema}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::ErrorCode get_code() const { + return code; + } + + ::nebula::cpp2::ErrorCode& set_code( ::nebula::cpp2::ErrorCode code_) { + code = code_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.code = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return code; + } + const nebula::HostAddr& get_leader() const&; + nebula::HostAddr get_leader() &&; + + template + nebula::HostAddr& set_leader(T_GetEdgeResp_leader_struct_setter&& leader_) { + leader = std::forward(leader_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.leader = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return leader; + } + const ::nebula::meta::cpp2::Schema& get_schema() const&; + ::nebula::meta::cpp2::Schema get_schema() &&; + + template + ::nebula::meta::cpp2::Schema& set_schema(T_GetEdgeResp_schema_struct_setter&& schema_) { + schema = std::forward(schema_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.schema = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return schema; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< GetEdgeResp >; + friend void swap(GetEdgeResp& a, GetEdgeResp& b); +}; + +template +uint32_t GetEdgeResp::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class DropEdgeReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = DropEdgeReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + DropEdgeReq() : + space_id(0), + if_exists(0) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + DropEdgeReq(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, ::std::string edge_name__arg, bool if_exists__arg); + + DropEdgeReq(DropEdgeReq&&) = default; + + DropEdgeReq(const DropEdgeReq&) = default; + + + DropEdgeReq& operator=(DropEdgeReq&&) = default; + + DropEdgeReq& operator=(const DropEdgeReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::GraphSpaceID space_id; + private: + ::std::string edge_name; + private: + bool if_exists; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool space_id; + bool edge_name; + bool if_exists; + } __isset = {}; + bool operator==(const DropEdgeReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const DropEdgeReq& __x, const DropEdgeReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const DropEdgeReq& rhs) const; +#ifndef SWIG + friend bool operator>(const DropEdgeReq& __x, const DropEdgeReq& __y) { + return __y < __x; + } + friend bool operator<=(const DropEdgeReq& __x, const DropEdgeReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const DropEdgeReq& __x, const DropEdgeReq& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const& { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const&& { + return {std::move(this->space_id), __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() & { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() && { + return {std::move(this->space_id), __isset.space_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref edge_name_ref() const& { + return {this->edge_name, __isset.edge_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref edge_name_ref() const&& { + return {std::move(this->edge_name), __isset.edge_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref edge_name_ref() & { + return {this->edge_name, __isset.edge_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref edge_name_ref() && { + return {std::move(this->edge_name), __isset.edge_name}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref if_exists_ref() const& { + return {this->if_exists, __isset.if_exists}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref if_exists_ref() const&& { + return {std::move(this->if_exists), __isset.if_exists}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref if_exists_ref() & { + return {this->if_exists, __isset.if_exists}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref if_exists_ref() && { + return {std::move(this->if_exists), __isset.if_exists}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::GraphSpaceID get_space_id() const { + return space_id; + } + + ::nebula::cpp2::GraphSpaceID& set_space_id( ::nebula::cpp2::GraphSpaceID space_id_) { + space_id = space_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.space_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return space_id; + } + + const ::std::string& get_edge_name() const& { + return edge_name; + } + + ::std::string get_edge_name() && { + return std::move(edge_name); + } + + template + ::std::string& set_edge_name(T_DropEdgeReq_edge_name_struct_setter&& edge_name_) { + edge_name = std::forward(edge_name_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.edge_name = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return edge_name; + } + + bool get_if_exists() const { + return if_exists; + } + + bool& set_if_exists(bool if_exists_) { + if_exists = if_exists_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.if_exists = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return if_exists; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< DropEdgeReq >; + friend void swap(DropEdgeReq& a, DropEdgeReq& b); +}; + +template +uint32_t DropEdgeReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class ListEdgesReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = ListEdgesReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + ListEdgesReq() : + space_id(0) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + ListEdgesReq(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg); + + ListEdgesReq(ListEdgesReq&&) = default; + + ListEdgesReq(const ListEdgesReq&) = default; + + + ListEdgesReq& operator=(ListEdgesReq&&) = default; + + ListEdgesReq& operator=(const ListEdgesReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::GraphSpaceID space_id; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool space_id; + } __isset = {}; + bool operator==(const ListEdgesReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const ListEdgesReq& __x, const ListEdgesReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const ListEdgesReq& rhs) const; +#ifndef SWIG + friend bool operator>(const ListEdgesReq& __x, const ListEdgesReq& __y) { + return __y < __x; + } + friend bool operator<=(const ListEdgesReq& __x, const ListEdgesReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const ListEdgesReq& __x, const ListEdgesReq& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const& { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const&& { + return {std::move(this->space_id), __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() & { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() && { + return {std::move(this->space_id), __isset.space_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::GraphSpaceID get_space_id() const { + return space_id; + } + + ::nebula::cpp2::GraphSpaceID& set_space_id( ::nebula::cpp2::GraphSpaceID space_id_) { + space_id = space_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.space_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return space_id; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< ListEdgesReq >; + friend void swap(ListEdgesReq& a, ListEdgesReq& b); +}; + +template +uint32_t ListEdgesReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class ListEdgesResp final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = ListEdgesResp; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + ListEdgesResp() : + code( ::nebula::cpp2::ErrorCode::SUCCEEDED) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + ListEdgesResp(apache::thrift::FragileConstructor, ::nebula::cpp2::ErrorCode code__arg, nebula::HostAddr leader__arg, ::std::vector< ::nebula::meta::cpp2::EdgeItem> edges__arg); + + ListEdgesResp(ListEdgesResp&&) = default; + + ListEdgesResp(const ListEdgesResp&) = default; + + + ListEdgesResp& operator=(ListEdgesResp&&) = default; + + ListEdgesResp& operator=(const ListEdgesResp&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::ErrorCode code; + private: + nebula::HostAddr leader; + private: + ::std::vector< ::nebula::meta::cpp2::EdgeItem> edges; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool code; + bool leader; + bool edges; + } __isset = {}; + bool operator==(const ListEdgesResp& rhs) const; +#ifndef SWIG + friend bool operator!=(const ListEdgesResp& __x, const ListEdgesResp& __y) { + return !(__x == __y); + } +#endif + bool operator<(const ListEdgesResp& rhs) const; +#ifndef SWIG + friend bool operator>(const ListEdgesResp& __x, const ListEdgesResp& __y) { + return __y < __x; + } + friend bool operator<=(const ListEdgesResp& __x, const ListEdgesResp& __y) { + return !(__y < __x); + } + friend bool operator>=(const ListEdgesResp& __x, const ListEdgesResp& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() const& { + return {this->code, __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() const&& { + return {std::move(this->code), __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() & { + return {this->code, __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() && { + return {std::move(this->code), __isset.code}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() const& { + return {this->leader, __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() const&& { + return {std::move(this->leader), __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() & { + return {this->leader, __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() && { + return {std::move(this->leader), __isset.leader}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::field_ref edges_ref() const& { + return {this->edges, __isset.edges}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref edges_ref() const&& { + return {std::move(this->edges), __isset.edges}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref edges_ref() & { + return {this->edges, __isset.edges}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref edges_ref() && { + return {std::move(this->edges), __isset.edges}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::ErrorCode get_code() const { + return code; + } + + ::nebula::cpp2::ErrorCode& set_code( ::nebula::cpp2::ErrorCode code_) { + code = code_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.code = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return code; + } + const nebula::HostAddr& get_leader() const&; + nebula::HostAddr get_leader() &&; + + template + nebula::HostAddr& set_leader(T_ListEdgesResp_leader_struct_setter&& leader_) { + leader = std::forward(leader_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.leader = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return leader; + } + const ::std::vector< ::nebula::meta::cpp2::EdgeItem>& get_edges() const&; + ::std::vector< ::nebula::meta::cpp2::EdgeItem> get_edges() &&; + + template > + ::std::vector< ::nebula::meta::cpp2::EdgeItem>& set_edges(T_ListEdgesResp_edges_struct_setter&& edges_) { + edges = std::forward(edges_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.edges = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return edges; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< ListEdgesResp >; + friend void swap(ListEdgesResp& a, ListEdgesResp& b); +}; + +template +uint32_t ListEdgesResp::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class ListHostsReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = ListHostsReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + ListHostsReq() : + type( ::nebula::meta::cpp2::ListHostType::ALLOC) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + ListHostsReq(apache::thrift::FragileConstructor, ::nebula::meta::cpp2::ListHostType type__arg); + + ListHostsReq(ListHostsReq&&) = default; + + ListHostsReq(const ListHostsReq&) = default; + + + ListHostsReq& operator=(ListHostsReq&&) = default; + + ListHostsReq& operator=(const ListHostsReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::meta::cpp2::ListHostType type; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool type; + } __isset = {}; + bool operator==(const ListHostsReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const ListHostsReq& __x, const ListHostsReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const ListHostsReq& rhs) const; +#ifndef SWIG + friend bool operator>(const ListHostsReq& __x, const ListHostsReq& __y) { + return __y < __x; + } + friend bool operator<=(const ListHostsReq& __x, const ListHostsReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const ListHostsReq& __x, const ListHostsReq& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref type_ref() const& { + return {this->type, __isset.type}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref type_ref() const&& { + return {std::move(this->type), __isset.type}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref type_ref() & { + return {this->type, __isset.type}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref type_ref() && { + return {std::move(this->type), __isset.type}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::meta::cpp2::ListHostType get_type() const { + return type; + } + + ::nebula::meta::cpp2::ListHostType& set_type( ::nebula::meta::cpp2::ListHostType type_) { + type = type_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.type = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return type; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< ListHostsReq >; + friend void swap(ListHostsReq& a, ListHostsReq& b); +}; + +template +uint32_t ListHostsReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class ListHostsResp final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = ListHostsResp; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + ListHostsResp() : + code( ::nebula::cpp2::ErrorCode::SUCCEEDED) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + ListHostsResp(apache::thrift::FragileConstructor, ::nebula::cpp2::ErrorCode code__arg, nebula::HostAddr leader__arg, ::std::vector< ::nebula::meta::cpp2::HostItem> hosts__arg); + + ListHostsResp(ListHostsResp&&) = default; + + ListHostsResp(const ListHostsResp&) = default; + + + ListHostsResp& operator=(ListHostsResp&&) = default; + + ListHostsResp& operator=(const ListHostsResp&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::ErrorCode code; + private: + nebula::HostAddr leader; + private: + ::std::vector< ::nebula::meta::cpp2::HostItem> hosts; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool code; + bool leader; + bool hosts; + } __isset = {}; + bool operator==(const ListHostsResp& rhs) const; +#ifndef SWIG + friend bool operator!=(const ListHostsResp& __x, const ListHostsResp& __y) { + return !(__x == __y); + } +#endif + bool operator<(const ListHostsResp& rhs) const; +#ifndef SWIG + friend bool operator>(const ListHostsResp& __x, const ListHostsResp& __y) { + return __y < __x; + } + friend bool operator<=(const ListHostsResp& __x, const ListHostsResp& __y) { + return !(__y < __x); + } + friend bool operator>=(const ListHostsResp& __x, const ListHostsResp& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() const& { + return {this->code, __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() const&& { + return {std::move(this->code), __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() & { + return {this->code, __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() && { + return {std::move(this->code), __isset.code}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() const& { + return {this->leader, __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() const&& { + return {std::move(this->leader), __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() & { + return {this->leader, __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() && { + return {std::move(this->leader), __isset.leader}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::field_ref hosts_ref() const& { + return {this->hosts, __isset.hosts}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref hosts_ref() const&& { + return {std::move(this->hosts), __isset.hosts}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref hosts_ref() & { + return {this->hosts, __isset.hosts}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref hosts_ref() && { + return {std::move(this->hosts), __isset.hosts}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::ErrorCode get_code() const { + return code; + } + + ::nebula::cpp2::ErrorCode& set_code( ::nebula::cpp2::ErrorCode code_) { + code = code_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.code = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return code; + } + const nebula::HostAddr& get_leader() const&; + nebula::HostAddr get_leader() &&; + + template + nebula::HostAddr& set_leader(T_ListHostsResp_leader_struct_setter&& leader_) { + leader = std::forward(leader_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.leader = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return leader; + } + const ::std::vector< ::nebula::meta::cpp2::HostItem>& get_hosts() const&; + ::std::vector< ::nebula::meta::cpp2::HostItem> get_hosts() &&; + + template > + ::std::vector< ::nebula::meta::cpp2::HostItem>& set_hosts(T_ListHostsResp_hosts_struct_setter&& hosts_) { + hosts = std::forward(hosts_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.hosts = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return hosts; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< ListHostsResp >; + friend void swap(ListHostsResp& a, ListHostsResp& b); +}; + +template +uint32_t ListHostsResp::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class PartItem final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = PartItem; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + PartItem() : + part_id(0) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + PartItem(apache::thrift::FragileConstructor, ::nebula::cpp2::PartitionID part_id__arg, nebula::HostAddr leader__arg, ::std::vector peers__arg, ::std::vector losts__arg); + + PartItem(PartItem&&) = default; + + PartItem(const PartItem&) = default; + + + PartItem& operator=(PartItem&&) = default; + + PartItem& operator=(const PartItem&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + public: + ::nebula::cpp2::PartitionID part_id; + private: + nebula::HostAddr leader; + public: + ::std::vector peers; + public: + ::std::vector losts; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool leader; + } __isset = {}; + bool operator==(const PartItem& rhs) const; +#ifndef SWIG + friend bool operator!=(const PartItem& __x, const PartItem& __y) { + return !(__x == __y); + } +#endif + bool operator<(const PartItem& rhs) const; +#ifndef SWIG + friend bool operator>(const PartItem& __x, const PartItem& __y) { + return __y < __x; + } + friend bool operator<=(const PartItem& __x, const PartItem& __y) { + return !(__y < __x); + } + friend bool operator>=(const PartItem& __x, const PartItem& __y) { + return !(__x < __y); + } +#endif + template + FOLLY_ERASE ::apache::thrift::required_field_ref part_id_ref() const& { + return ::apache::thrift::required_field_ref{this->part_id}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref part_id_ref() const&& { + return ::apache::thrift::required_field_ref{std::move(this->part_id)}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref part_id_ref() & { + return ::apache::thrift::required_field_ref{this->part_id}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref part_id_ref() && { + return ::apache::thrift::required_field_ref{std::move(this->part_id)}; + } + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::optional_field_ref leader_ref() const& { + return {this->leader, __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref leader_ref() const&& { + return {std::move(this->leader), __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref leader_ref() & { + return {this->leader, __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref leader_ref() && { + return {std::move(this->leader), __isset.leader}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + template > + FOLLY_ERASE ::apache::thrift::required_field_ref peers_ref() const& { + return ::apache::thrift::required_field_ref{this->peers}; + } + + template > + FOLLY_ERASE ::apache::thrift::required_field_ref peers_ref() const&& { + return ::apache::thrift::required_field_ref{std::move(this->peers)}; + } + + template > + FOLLY_ERASE ::apache::thrift::required_field_ref peers_ref() & { + return ::apache::thrift::required_field_ref{this->peers}; + } + + template > + FOLLY_ERASE ::apache::thrift::required_field_ref peers_ref() && { + return ::apache::thrift::required_field_ref{std::move(this->peers)}; + } + template > + FOLLY_ERASE ::apache::thrift::required_field_ref losts_ref() const& { + return ::apache::thrift::required_field_ref{this->losts}; + } + + template > + FOLLY_ERASE ::apache::thrift::required_field_ref losts_ref() const&& { + return ::apache::thrift::required_field_ref{std::move(this->losts)}; + } + + template > + FOLLY_ERASE ::apache::thrift::required_field_ref losts_ref() & { + return ::apache::thrift::required_field_ref{this->losts}; + } + + template > + FOLLY_ERASE ::apache::thrift::required_field_ref losts_ref() && { + return ::apache::thrift::required_field_ref{std::move(this->losts)}; + } + + ::nebula::cpp2::PartitionID get_part_id() const { + return part_id; + } + + ::nebula::cpp2::PartitionID& set_part_id( ::nebula::cpp2::PartitionID part_id_) { + part_id = part_id_; + return part_id; + } + const nebula::HostAddr* get_leader() const&; + nebula::HostAddr* get_leader() &; + nebula::HostAddr* get_leader() && = delete; + + template + nebula::HostAddr& set_leader(T_PartItem_leader_struct_setter&& leader_) { + leader = std::forward(leader_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.leader = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return leader; + } + const ::std::vector& get_peers() const&; + ::std::vector get_peers() &&; + + template > + ::std::vector& set_peers(T_PartItem_peers_struct_setter&& peers_) { + peers = std::forward(peers_); + return peers; + } + const ::std::vector& get_losts() const&; + ::std::vector get_losts() &&; + + template > + ::std::vector& set_losts(T_PartItem_losts_struct_setter&& losts_) { + losts = std::forward(losts_); + return losts; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< PartItem >; + friend void swap(PartItem& a, PartItem& b); +}; + +template +uint32_t PartItem::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class ListPartsReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = ListPartsReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + ListPartsReq() : + space_id(0) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + ListPartsReq(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, ::std::vector< ::nebula::cpp2::PartitionID> part_ids__arg); + + ListPartsReq(ListPartsReq&&) = default; + + ListPartsReq(const ListPartsReq&) = default; + + + ListPartsReq& operator=(ListPartsReq&&) = default; + + ListPartsReq& operator=(const ListPartsReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::GraphSpaceID space_id; + private: + ::std::vector< ::nebula::cpp2::PartitionID> part_ids; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool space_id; + bool part_ids; + } __isset = {}; + bool operator==(const ListPartsReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const ListPartsReq& __x, const ListPartsReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const ListPartsReq& rhs) const; +#ifndef SWIG + friend bool operator>(const ListPartsReq& __x, const ListPartsReq& __y) { + return __y < __x; + } + friend bool operator<=(const ListPartsReq& __x, const ListPartsReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const ListPartsReq& __x, const ListPartsReq& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const& { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const&& { + return {std::move(this->space_id), __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() & { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() && { + return {std::move(this->space_id), __isset.space_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::field_ref part_ids_ref() const& { + return {this->part_ids, __isset.part_ids}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref part_ids_ref() const&& { + return {std::move(this->part_ids), __isset.part_ids}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref part_ids_ref() & { + return {this->part_ids, __isset.part_ids}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref part_ids_ref() && { + return {std::move(this->part_ids), __isset.part_ids}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::GraphSpaceID get_space_id() const { + return space_id; + } + + ::nebula::cpp2::GraphSpaceID& set_space_id( ::nebula::cpp2::GraphSpaceID space_id_) { + space_id = space_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.space_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return space_id; + } + const ::std::vector< ::nebula::cpp2::PartitionID>& get_part_ids() const&; + ::std::vector< ::nebula::cpp2::PartitionID> get_part_ids() &&; + + template > + ::std::vector< ::nebula::cpp2::PartitionID>& set_part_ids(T_ListPartsReq_part_ids_struct_setter&& part_ids_) { + part_ids = std::forward(part_ids_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.part_ids = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return part_ids; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< ListPartsReq >; + friend void swap(ListPartsReq& a, ListPartsReq& b); +}; + +template +uint32_t ListPartsReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class ListPartsResp final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = ListPartsResp; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + ListPartsResp() : + code( ::nebula::cpp2::ErrorCode::SUCCEEDED) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + ListPartsResp(apache::thrift::FragileConstructor, ::nebula::cpp2::ErrorCode code__arg, nebula::HostAddr leader__arg, ::std::vector< ::nebula::meta::cpp2::PartItem> parts__arg); + + ListPartsResp(ListPartsResp&&) = default; + + ListPartsResp(const ListPartsResp&) = default; + + + ListPartsResp& operator=(ListPartsResp&&) = default; + + ListPartsResp& operator=(const ListPartsResp&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::ErrorCode code; + private: + nebula::HostAddr leader; + private: + ::std::vector< ::nebula::meta::cpp2::PartItem> parts; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool code; + bool leader; + bool parts; + } __isset = {}; + bool operator==(const ListPartsResp& rhs) const; +#ifndef SWIG + friend bool operator!=(const ListPartsResp& __x, const ListPartsResp& __y) { + return !(__x == __y); + } +#endif + bool operator<(const ListPartsResp& rhs) const; +#ifndef SWIG + friend bool operator>(const ListPartsResp& __x, const ListPartsResp& __y) { + return __y < __x; + } + friend bool operator<=(const ListPartsResp& __x, const ListPartsResp& __y) { + return !(__y < __x); + } + friend bool operator>=(const ListPartsResp& __x, const ListPartsResp& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() const& { + return {this->code, __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() const&& { + return {std::move(this->code), __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() & { + return {this->code, __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() && { + return {std::move(this->code), __isset.code}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() const& { + return {this->leader, __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() const&& { + return {std::move(this->leader), __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() & { + return {this->leader, __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() && { + return {std::move(this->leader), __isset.leader}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::field_ref parts_ref() const& { + return {this->parts, __isset.parts}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref parts_ref() const&& { + return {std::move(this->parts), __isset.parts}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref parts_ref() & { + return {this->parts, __isset.parts}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref parts_ref() && { + return {std::move(this->parts), __isset.parts}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::ErrorCode get_code() const { + return code; + } + + ::nebula::cpp2::ErrorCode& set_code( ::nebula::cpp2::ErrorCode code_) { + code = code_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.code = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return code; + } + const nebula::HostAddr& get_leader() const&; + nebula::HostAddr get_leader() &&; + + template + nebula::HostAddr& set_leader(T_ListPartsResp_leader_struct_setter&& leader_) { + leader = std::forward(leader_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.leader = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return leader; + } + const ::std::vector< ::nebula::meta::cpp2::PartItem>& get_parts() const&; + ::std::vector< ::nebula::meta::cpp2::PartItem> get_parts() &&; + + template > + ::std::vector< ::nebula::meta::cpp2::PartItem>& set_parts(T_ListPartsResp_parts_struct_setter&& parts_) { + parts = std::forward(parts_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.parts = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return parts; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< ListPartsResp >; + friend void swap(ListPartsResp& a, ListPartsResp& b); +}; + +template +uint32_t ListPartsResp::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class GetPartsAllocReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = GetPartsAllocReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + GetPartsAllocReq() : + space_id(0) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + GetPartsAllocReq(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg); + + GetPartsAllocReq(GetPartsAllocReq&&) = default; + + GetPartsAllocReq(const GetPartsAllocReq&) = default; + + + GetPartsAllocReq& operator=(GetPartsAllocReq&&) = default; + + GetPartsAllocReq& operator=(const GetPartsAllocReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::GraphSpaceID space_id; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool space_id; + } __isset = {}; + bool operator==(const GetPartsAllocReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const GetPartsAllocReq& __x, const GetPartsAllocReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const GetPartsAllocReq& rhs) const; +#ifndef SWIG + friend bool operator>(const GetPartsAllocReq& __x, const GetPartsAllocReq& __y) { + return __y < __x; + } + friend bool operator<=(const GetPartsAllocReq& __x, const GetPartsAllocReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const GetPartsAllocReq& __x, const GetPartsAllocReq& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const& { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const&& { + return {std::move(this->space_id), __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() & { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() && { + return {std::move(this->space_id), __isset.space_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::GraphSpaceID get_space_id() const { + return space_id; + } + + ::nebula::cpp2::GraphSpaceID& set_space_id( ::nebula::cpp2::GraphSpaceID space_id_) { + space_id = space_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.space_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return space_id; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< GetPartsAllocReq >; + friend void swap(GetPartsAllocReq& a, GetPartsAllocReq& b); +}; + +template +uint32_t GetPartsAllocReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class GetPartsAllocResp final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = GetPartsAllocResp; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + GetPartsAllocResp() : + code( ::nebula::cpp2::ErrorCode::SUCCEEDED) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + GetPartsAllocResp(apache::thrift::FragileConstructor, ::nebula::cpp2::ErrorCode code__arg, nebula::HostAddr leader__arg, std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector> parts__arg, std::unordered_map< ::nebula::cpp2::PartitionID, int64_t> terms__arg); + + GetPartsAllocResp(GetPartsAllocResp&&) = default; + + GetPartsAllocResp(const GetPartsAllocResp&) = default; + + + GetPartsAllocResp& operator=(GetPartsAllocResp&&) = default; + + GetPartsAllocResp& operator=(const GetPartsAllocResp&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::ErrorCode code; + private: + nebula::HostAddr leader; + private: + std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector> parts; + private: + std::unordered_map< ::nebula::cpp2::PartitionID, int64_t> terms; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool code; + bool leader; + bool parts; + bool terms; + } __isset = {}; + bool operator==(const GetPartsAllocResp& rhs) const; +#ifndef SWIG + friend bool operator!=(const GetPartsAllocResp& __x, const GetPartsAllocResp& __y) { + return !(__x == __y); + } +#endif + bool operator<(const GetPartsAllocResp& rhs) const; +#ifndef SWIG + friend bool operator>(const GetPartsAllocResp& __x, const GetPartsAllocResp& __y) { + return __y < __x; + } + friend bool operator<=(const GetPartsAllocResp& __x, const GetPartsAllocResp& __y) { + return !(__y < __x); + } + friend bool operator>=(const GetPartsAllocResp& __x, const GetPartsAllocResp& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() const& { + return {this->code, __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() const&& { + return {std::move(this->code), __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() & { + return {this->code, __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() && { + return {std::move(this->code), __isset.code}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() const& { + return {this->leader, __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() const&& { + return {std::move(this->leader), __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() & { + return {this->leader, __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() && { + return {std::move(this->leader), __isset.leader}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template >> + FOLLY_ERASE ::apache::thrift::field_ref parts_ref() const& { + return {this->parts, __isset.parts}; + } + + template >> + FOLLY_ERASE ::apache::thrift::field_ref parts_ref() const&& { + return {std::move(this->parts), __isset.parts}; + } + + template >> + FOLLY_ERASE ::apache::thrift::field_ref parts_ref() & { + return {this->parts, __isset.parts}; + } + + template >> + FOLLY_ERASE ::apache::thrift::field_ref parts_ref() && { + return {std::move(this->parts), __isset.parts}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::optional_field_ref terms_ref() const& { + return {this->terms, __isset.terms}; + } + + template > + FOLLY_ERASE ::apache::thrift::optional_field_ref terms_ref() const&& { + return {std::move(this->terms), __isset.terms}; + } + + template > + FOLLY_ERASE ::apache::thrift::optional_field_ref terms_ref() & { + return {this->terms, __isset.terms}; + } + + template > + FOLLY_ERASE ::apache::thrift::optional_field_ref terms_ref() && { + return {std::move(this->terms), __isset.terms}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::ErrorCode get_code() const { + return code; + } + + ::nebula::cpp2::ErrorCode& set_code( ::nebula::cpp2::ErrorCode code_) { + code = code_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.code = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return code; + } + const nebula::HostAddr& get_leader() const&; + nebula::HostAddr get_leader() &&; + + template + nebula::HostAddr& set_leader(T_GetPartsAllocResp_leader_struct_setter&& leader_) { + leader = std::forward(leader_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.leader = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return leader; + } + const std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector>& get_parts() const&; + std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector> get_parts() &&; + + template >> + std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector>& set_parts(T_GetPartsAllocResp_parts_struct_setter&& parts_) { + parts = std::forward(parts_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.parts = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return parts; + } + const std::unordered_map< ::nebula::cpp2::PartitionID, int64_t>* get_terms() const&; + std::unordered_map< ::nebula::cpp2::PartitionID, int64_t>* get_terms() &; + std::unordered_map< ::nebula::cpp2::PartitionID, int64_t>* get_terms() && = delete; + + template > + std::unordered_map< ::nebula::cpp2::PartitionID, int64_t>& set_terms(T_GetPartsAllocResp_terms_struct_setter&& terms_) { + terms = std::forward(terms_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.terms = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return terms; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< GetPartsAllocResp >; + friend void swap(GetPartsAllocResp& a, GetPartsAllocResp& b); +}; + +template +uint32_t GetPartsAllocResp::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class MultiPutReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = MultiPutReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + MultiPutReq() {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + MultiPutReq(apache::thrift::FragileConstructor, ::std::string segment__arg, ::std::vector pairs__arg); + + MultiPutReq(MultiPutReq&&) = default; + + MultiPutReq(const MultiPutReq&) = default; + + + MultiPutReq& operator=(MultiPutReq&&) = default; + + MultiPutReq& operator=(const MultiPutReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::std::string segment; + private: + ::std::vector pairs; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool segment; + bool pairs; + } __isset = {}; + bool operator==(const MultiPutReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const MultiPutReq& __x, const MultiPutReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const MultiPutReq& rhs) const; +#ifndef SWIG + friend bool operator>(const MultiPutReq& __x, const MultiPutReq& __y) { + return __y < __x; + } + friend bool operator<=(const MultiPutReq& __x, const MultiPutReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const MultiPutReq& __x, const MultiPutReq& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref segment_ref() const& { + return {this->segment, __isset.segment}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref segment_ref() const&& { + return {std::move(this->segment), __isset.segment}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref segment_ref() & { + return {this->segment, __isset.segment}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref segment_ref() && { + return {std::move(this->segment), __isset.segment}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::field_ref pairs_ref() const& { + return {this->pairs, __isset.pairs}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref pairs_ref() const&& { + return {std::move(this->pairs), __isset.pairs}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref pairs_ref() & { + return {this->pairs, __isset.pairs}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref pairs_ref() && { + return {std::move(this->pairs), __isset.pairs}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + const ::std::string& get_segment() const& { + return segment; + } + + ::std::string get_segment() && { + return std::move(segment); + } + + template + ::std::string& set_segment(T_MultiPutReq_segment_struct_setter&& segment_) { + segment = std::forward(segment_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.segment = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return segment; + } + const ::std::vector& get_pairs() const&; + ::std::vector get_pairs() &&; + + template > + ::std::vector& set_pairs(T_MultiPutReq_pairs_struct_setter&& pairs_) { + pairs = std::forward(pairs_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.pairs = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return pairs; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< MultiPutReq >; + friend void swap(MultiPutReq& a, MultiPutReq& b); +}; + +template +uint32_t MultiPutReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class GetReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = GetReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + GetReq() {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + GetReq(apache::thrift::FragileConstructor, ::std::string segment__arg, ::std::string key__arg); + + GetReq(GetReq&&) = default; + + GetReq(const GetReq&) = default; + + + GetReq& operator=(GetReq&&) = default; + + GetReq& operator=(const GetReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::std::string segment; + private: + ::std::string key; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool segment; + bool key; + } __isset = {}; + bool operator==(const GetReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const GetReq& __x, const GetReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const GetReq& rhs) const; +#ifndef SWIG + friend bool operator>(const GetReq& __x, const GetReq& __y) { + return __y < __x; + } + friend bool operator<=(const GetReq& __x, const GetReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const GetReq& __x, const GetReq& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref segment_ref() const& { + return {this->segment, __isset.segment}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref segment_ref() const&& { + return {std::move(this->segment), __isset.segment}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref segment_ref() & { + return {this->segment, __isset.segment}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref segment_ref() && { + return {std::move(this->segment), __isset.segment}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref key_ref() const& { + return {this->key, __isset.key}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref key_ref() const&& { + return {std::move(this->key), __isset.key}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref key_ref() & { + return {this->key, __isset.key}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref key_ref() && { + return {std::move(this->key), __isset.key}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + const ::std::string& get_segment() const& { + return segment; + } + + ::std::string get_segment() && { + return std::move(segment); + } + + template + ::std::string& set_segment(T_GetReq_segment_struct_setter&& segment_) { + segment = std::forward(segment_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.segment = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return segment; + } + + const ::std::string& get_key() const& { + return key; + } + + ::std::string get_key() && { + return std::move(key); + } + + template + ::std::string& set_key(T_GetReq_key_struct_setter&& key_) { + key = std::forward(key_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.key = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return key; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< GetReq >; + friend void swap(GetReq& a, GetReq& b); +}; + +template +uint32_t GetReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class GetResp final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = GetResp; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + GetResp() : + code( ::nebula::cpp2::ErrorCode::SUCCEEDED) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + GetResp(apache::thrift::FragileConstructor, ::nebula::cpp2::ErrorCode code__arg, nebula::HostAddr leader__arg, ::std::string value__arg); + + GetResp(GetResp&&) = default; + + GetResp(const GetResp&) = default; + + + GetResp& operator=(GetResp&&) = default; + + GetResp& operator=(const GetResp&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::ErrorCode code; + private: + nebula::HostAddr leader; + private: + ::std::string value; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool code; + bool leader; + bool value; + } __isset = {}; + bool operator==(const GetResp& rhs) const; +#ifndef SWIG + friend bool operator!=(const GetResp& __x, const GetResp& __y) { + return !(__x == __y); + } +#endif + bool operator<(const GetResp& rhs) const; +#ifndef SWIG + friend bool operator>(const GetResp& __x, const GetResp& __y) { + return __y < __x; + } + friend bool operator<=(const GetResp& __x, const GetResp& __y) { + return !(__y < __x); + } + friend bool operator>=(const GetResp& __x, const GetResp& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() const& { + return {this->code, __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() const&& { + return {std::move(this->code), __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() & { + return {this->code, __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() && { + return {std::move(this->code), __isset.code}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() const& { + return {this->leader, __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() const&& { + return {std::move(this->leader), __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() & { + return {this->leader, __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() && { + return {std::move(this->leader), __isset.leader}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref value_ref() const& { + return {this->value, __isset.value}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref value_ref() const&& { + return {std::move(this->value), __isset.value}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref value_ref() & { + return {this->value, __isset.value}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref value_ref() && { + return {std::move(this->value), __isset.value}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::ErrorCode get_code() const { + return code; + } + + ::nebula::cpp2::ErrorCode& set_code( ::nebula::cpp2::ErrorCode code_) { + code = code_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.code = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return code; + } + const nebula::HostAddr& get_leader() const&; + nebula::HostAddr get_leader() &&; + + template + nebula::HostAddr& set_leader(T_GetResp_leader_struct_setter&& leader_) { + leader = std::forward(leader_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.leader = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return leader; + } + + const ::std::string& get_value() const& { + return value; + } + + ::std::string get_value() && { + return std::move(value); + } + + template + ::std::string& set_value(T_GetResp_value_struct_setter&& value_) { + value = std::forward(value_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.value = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return value; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< GetResp >; + friend void swap(GetResp& a, GetResp& b); +}; + +template +uint32_t GetResp::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class MultiGetReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = MultiGetReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + MultiGetReq() {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + MultiGetReq(apache::thrift::FragileConstructor, ::std::string segment__arg, ::std::vector<::std::string> keys__arg); + + MultiGetReq(MultiGetReq&&) = default; + + MultiGetReq(const MultiGetReq&) = default; + + + MultiGetReq& operator=(MultiGetReq&&) = default; + + MultiGetReq& operator=(const MultiGetReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::std::string segment; + private: + ::std::vector<::std::string> keys; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool segment; + bool keys; + } __isset = {}; + bool operator==(const MultiGetReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const MultiGetReq& __x, const MultiGetReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const MultiGetReq& rhs) const; +#ifndef SWIG + friend bool operator>(const MultiGetReq& __x, const MultiGetReq& __y) { + return __y < __x; + } + friend bool operator<=(const MultiGetReq& __x, const MultiGetReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const MultiGetReq& __x, const MultiGetReq& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref segment_ref() const& { + return {this->segment, __isset.segment}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref segment_ref() const&& { + return {std::move(this->segment), __isset.segment}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref segment_ref() & { + return {this->segment, __isset.segment}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref segment_ref() && { + return {std::move(this->segment), __isset.segment}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::field_ref keys_ref() const& { + return {this->keys, __isset.keys}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref keys_ref() const&& { + return {std::move(this->keys), __isset.keys}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref keys_ref() & { + return {this->keys, __isset.keys}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref keys_ref() && { + return {std::move(this->keys), __isset.keys}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + const ::std::string& get_segment() const& { + return segment; + } + + ::std::string get_segment() && { + return std::move(segment); + } + + template + ::std::string& set_segment(T_MultiGetReq_segment_struct_setter&& segment_) { + segment = std::forward(segment_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.segment = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return segment; + } + const ::std::vector<::std::string>& get_keys() const&; + ::std::vector<::std::string> get_keys() &&; + + template > + ::std::vector<::std::string>& set_keys(T_MultiGetReq_keys_struct_setter&& keys_) { + keys = std::forward(keys_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.keys = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return keys; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< MultiGetReq >; + friend void swap(MultiGetReq& a, MultiGetReq& b); +}; + +template +uint32_t MultiGetReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class MultiGetResp final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = MultiGetResp; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + MultiGetResp() : + code( ::nebula::cpp2::ErrorCode::SUCCEEDED) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + MultiGetResp(apache::thrift::FragileConstructor, ::nebula::cpp2::ErrorCode code__arg, nebula::HostAddr leader__arg, ::std::vector<::std::string> values__arg); + + MultiGetResp(MultiGetResp&&) = default; + + MultiGetResp(const MultiGetResp&) = default; + + + MultiGetResp& operator=(MultiGetResp&&) = default; + + MultiGetResp& operator=(const MultiGetResp&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::ErrorCode code; + private: + nebula::HostAddr leader; + private: + ::std::vector<::std::string> values; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool code; + bool leader; + bool values; + } __isset = {}; + bool operator==(const MultiGetResp& rhs) const; +#ifndef SWIG + friend bool operator!=(const MultiGetResp& __x, const MultiGetResp& __y) { + return !(__x == __y); + } +#endif + bool operator<(const MultiGetResp& rhs) const; +#ifndef SWIG + friend bool operator>(const MultiGetResp& __x, const MultiGetResp& __y) { + return __y < __x; + } + friend bool operator<=(const MultiGetResp& __x, const MultiGetResp& __y) { + return !(__y < __x); + } + friend bool operator>=(const MultiGetResp& __x, const MultiGetResp& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() const& { + return {this->code, __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() const&& { + return {std::move(this->code), __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() & { + return {this->code, __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() && { + return {std::move(this->code), __isset.code}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() const& { + return {this->leader, __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() const&& { + return {std::move(this->leader), __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() & { + return {this->leader, __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() && { + return {std::move(this->leader), __isset.leader}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::field_ref values_ref() const& { + return {this->values, __isset.values}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref values_ref() const&& { + return {std::move(this->values), __isset.values}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref values_ref() & { + return {this->values, __isset.values}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref values_ref() && { + return {std::move(this->values), __isset.values}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::ErrorCode get_code() const { + return code; + } + + ::nebula::cpp2::ErrorCode& set_code( ::nebula::cpp2::ErrorCode code_) { + code = code_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.code = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return code; + } + const nebula::HostAddr& get_leader() const&; + nebula::HostAddr get_leader() &&; + + template + nebula::HostAddr& set_leader(T_MultiGetResp_leader_struct_setter&& leader_) { + leader = std::forward(leader_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.leader = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return leader; + } + const ::std::vector<::std::string>& get_values() const&; + ::std::vector<::std::string> get_values() &&; + + template > + ::std::vector<::std::string>& set_values(T_MultiGetResp_values_struct_setter&& values_) { + values = std::forward(values_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.values = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return values; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< MultiGetResp >; + friend void swap(MultiGetResp& a, MultiGetResp& b); +}; + +template +uint32_t MultiGetResp::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class RemoveReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = RemoveReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + RemoveReq() {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + RemoveReq(apache::thrift::FragileConstructor, ::std::string segment__arg, ::std::string key__arg); + + RemoveReq(RemoveReq&&) = default; + + RemoveReq(const RemoveReq&) = default; + + + RemoveReq& operator=(RemoveReq&&) = default; + + RemoveReq& operator=(const RemoveReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::std::string segment; + private: + ::std::string key; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool segment; + bool key; + } __isset = {}; + bool operator==(const RemoveReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const RemoveReq& __x, const RemoveReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const RemoveReq& rhs) const; +#ifndef SWIG + friend bool operator>(const RemoveReq& __x, const RemoveReq& __y) { + return __y < __x; + } + friend bool operator<=(const RemoveReq& __x, const RemoveReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const RemoveReq& __x, const RemoveReq& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref segment_ref() const& { + return {this->segment, __isset.segment}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref segment_ref() const&& { + return {std::move(this->segment), __isset.segment}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref segment_ref() & { + return {this->segment, __isset.segment}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref segment_ref() && { + return {std::move(this->segment), __isset.segment}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref key_ref() const& { + return {this->key, __isset.key}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref key_ref() const&& { + return {std::move(this->key), __isset.key}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref key_ref() & { + return {this->key, __isset.key}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref key_ref() && { + return {std::move(this->key), __isset.key}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + const ::std::string& get_segment() const& { + return segment; + } + + ::std::string get_segment() && { + return std::move(segment); + } + + template + ::std::string& set_segment(T_RemoveReq_segment_struct_setter&& segment_) { + segment = std::forward(segment_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.segment = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return segment; + } + + const ::std::string& get_key() const& { + return key; + } + + ::std::string get_key() && { + return std::move(key); + } + + template + ::std::string& set_key(T_RemoveReq_key_struct_setter&& key_) { + key = std::forward(key_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.key = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return key; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< RemoveReq >; + friend void swap(RemoveReq& a, RemoveReq& b); +}; + +template +uint32_t RemoveReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class RemoveRangeReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = RemoveRangeReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + RemoveRangeReq() {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + RemoveRangeReq(apache::thrift::FragileConstructor, ::std::string segment__arg, ::std::string start__arg, ::std::string end__arg); + + RemoveRangeReq(RemoveRangeReq&&) = default; + + RemoveRangeReq(const RemoveRangeReq&) = default; + + + RemoveRangeReq& operator=(RemoveRangeReq&&) = default; + + RemoveRangeReq& operator=(const RemoveRangeReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::std::string segment; + private: + ::std::string start; + private: + ::std::string end; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool segment; + bool start; + bool end; + } __isset = {}; + bool operator==(const RemoveRangeReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const RemoveRangeReq& __x, const RemoveRangeReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const RemoveRangeReq& rhs) const; +#ifndef SWIG + friend bool operator>(const RemoveRangeReq& __x, const RemoveRangeReq& __y) { + return __y < __x; + } + friend bool operator<=(const RemoveRangeReq& __x, const RemoveRangeReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const RemoveRangeReq& __x, const RemoveRangeReq& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref segment_ref() const& { + return {this->segment, __isset.segment}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref segment_ref() const&& { + return {std::move(this->segment), __isset.segment}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref segment_ref() & { + return {this->segment, __isset.segment}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref segment_ref() && { + return {std::move(this->segment), __isset.segment}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref start_ref() const& { + return {this->start, __isset.start}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref start_ref() const&& { + return {std::move(this->start), __isset.start}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref start_ref() & { + return {this->start, __isset.start}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref start_ref() && { + return {std::move(this->start), __isset.start}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref end_ref() const& { + return {this->end, __isset.end}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref end_ref() const&& { + return {std::move(this->end), __isset.end}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref end_ref() & { + return {this->end, __isset.end}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref end_ref() && { + return {std::move(this->end), __isset.end}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + const ::std::string& get_segment() const& { + return segment; + } + + ::std::string get_segment() && { + return std::move(segment); + } + + template + ::std::string& set_segment(T_RemoveRangeReq_segment_struct_setter&& segment_) { + segment = std::forward(segment_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.segment = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return segment; + } + + const ::std::string& get_start() const& { + return start; + } + + ::std::string get_start() && { + return std::move(start); + } + + template + ::std::string& set_start(T_RemoveRangeReq_start_struct_setter&& start_) { + start = std::forward(start_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.start = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return start; + } + + const ::std::string& get_end() const& { + return end; + } + + ::std::string get_end() && { + return std::move(end); + } + + template + ::std::string& set_end(T_RemoveRangeReq_end_struct_setter&& end_) { + end = std::forward(end_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.end = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return end; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< RemoveRangeReq >; + friend void swap(RemoveRangeReq& a, RemoveRangeReq& b); +}; + +template +uint32_t RemoveRangeReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class ScanReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = ScanReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + ScanReq() {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + ScanReq(apache::thrift::FragileConstructor, ::std::string segment__arg, ::std::string start__arg, ::std::string end__arg); + + ScanReq(ScanReq&&) = default; + + ScanReq(const ScanReq&) = default; + + + ScanReq& operator=(ScanReq&&) = default; + + ScanReq& operator=(const ScanReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::std::string segment; + private: + ::std::string start; + private: + ::std::string end; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool segment; + bool start; + bool end; + } __isset = {}; + bool operator==(const ScanReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const ScanReq& __x, const ScanReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const ScanReq& rhs) const; +#ifndef SWIG + friend bool operator>(const ScanReq& __x, const ScanReq& __y) { + return __y < __x; + } + friend bool operator<=(const ScanReq& __x, const ScanReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const ScanReq& __x, const ScanReq& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref segment_ref() const& { + return {this->segment, __isset.segment}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref segment_ref() const&& { + return {std::move(this->segment), __isset.segment}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref segment_ref() & { + return {this->segment, __isset.segment}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref segment_ref() && { + return {std::move(this->segment), __isset.segment}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref start_ref() const& { + return {this->start, __isset.start}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref start_ref() const&& { + return {std::move(this->start), __isset.start}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref start_ref() & { + return {this->start, __isset.start}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref start_ref() && { + return {std::move(this->start), __isset.start}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref end_ref() const& { + return {this->end, __isset.end}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref end_ref() const&& { + return {std::move(this->end), __isset.end}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref end_ref() & { + return {this->end, __isset.end}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref end_ref() && { + return {std::move(this->end), __isset.end}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + const ::std::string& get_segment() const& { + return segment; + } + + ::std::string get_segment() && { + return std::move(segment); + } + + template + ::std::string& set_segment(T_ScanReq_segment_struct_setter&& segment_) { + segment = std::forward(segment_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.segment = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return segment; + } + + const ::std::string& get_start() const& { + return start; + } + + ::std::string get_start() && { + return std::move(start); + } + + template + ::std::string& set_start(T_ScanReq_start_struct_setter&& start_) { + start = std::forward(start_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.start = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return start; + } + + const ::std::string& get_end() const& { + return end; + } + + ::std::string get_end() && { + return std::move(end); + } + + template + ::std::string& set_end(T_ScanReq_end_struct_setter&& end_) { + end = std::forward(end_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.end = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return end; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< ScanReq >; + friend void swap(ScanReq& a, ScanReq& b); +}; + +template +uint32_t ScanReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class ScanResp final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = ScanResp; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + ScanResp() : + code( ::nebula::cpp2::ErrorCode::SUCCEEDED) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + ScanResp(apache::thrift::FragileConstructor, ::nebula::cpp2::ErrorCode code__arg, nebula::HostAddr leader__arg, ::std::vector<::std::string> values__arg); + + ScanResp(ScanResp&&) = default; + + ScanResp(const ScanResp&) = default; + + + ScanResp& operator=(ScanResp&&) = default; + + ScanResp& operator=(const ScanResp&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::ErrorCode code; + private: + nebula::HostAddr leader; + private: + ::std::vector<::std::string> values; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool code; + bool leader; + bool values; + } __isset = {}; + bool operator==(const ScanResp& rhs) const; +#ifndef SWIG + friend bool operator!=(const ScanResp& __x, const ScanResp& __y) { + return !(__x == __y); + } +#endif + bool operator<(const ScanResp& rhs) const; +#ifndef SWIG + friend bool operator>(const ScanResp& __x, const ScanResp& __y) { + return __y < __x; + } + friend bool operator<=(const ScanResp& __x, const ScanResp& __y) { + return !(__y < __x); + } + friend bool operator>=(const ScanResp& __x, const ScanResp& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() const& { + return {this->code, __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() const&& { + return {std::move(this->code), __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() & { + return {this->code, __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() && { + return {std::move(this->code), __isset.code}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() const& { + return {this->leader, __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() const&& { + return {std::move(this->leader), __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() & { + return {this->leader, __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() && { + return {std::move(this->leader), __isset.leader}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::field_ref values_ref() const& { + return {this->values, __isset.values}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref values_ref() const&& { + return {std::move(this->values), __isset.values}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref values_ref() & { + return {this->values, __isset.values}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref values_ref() && { + return {std::move(this->values), __isset.values}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::ErrorCode get_code() const { + return code; + } + + ::nebula::cpp2::ErrorCode& set_code( ::nebula::cpp2::ErrorCode code_) { + code = code_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.code = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return code; + } + const nebula::HostAddr& get_leader() const&; + nebula::HostAddr get_leader() &&; + + template + nebula::HostAddr& set_leader(T_ScanResp_leader_struct_setter&& leader_) { + leader = std::forward(leader_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.leader = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return leader; + } + const ::std::vector<::std::string>& get_values() const&; + ::std::vector<::std::string> get_values() &&; + + template > + ::std::vector<::std::string>& set_values(T_ScanResp_values_struct_setter&& values_) { + values = std::forward(values_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.values = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return values; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< ScanResp >; + friend void swap(ScanResp& a, ScanResp& b); +}; + +template +uint32_t ScanResp::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class HBResp final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = HBResp; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + HBResp() : + code( ::nebula::cpp2::ErrorCode::SUCCEEDED), + cluster_id(0), + last_update_time_in_ms(0), + meta_version(0) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + HBResp(apache::thrift::FragileConstructor, ::nebula::cpp2::ErrorCode code__arg, nebula::HostAddr leader__arg, ::nebula::meta::cpp2::ClusterID cluster_id__arg, int64_t last_update_time_in_ms__arg, int32_t meta_version__arg); + + HBResp(HBResp&&) = default; + + HBResp(const HBResp&) = default; + + + HBResp& operator=(HBResp&&) = default; + + HBResp& operator=(const HBResp&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::ErrorCode code; + private: + nebula::HostAddr leader; + private: + ::nebula::meta::cpp2::ClusterID cluster_id; + private: + int64_t last_update_time_in_ms; + private: + int32_t meta_version; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool code; + bool leader; + bool cluster_id; + bool last_update_time_in_ms; + bool meta_version; + } __isset = {}; + bool operator==(const HBResp& rhs) const; +#ifndef SWIG + friend bool operator!=(const HBResp& __x, const HBResp& __y) { + return !(__x == __y); + } +#endif + bool operator<(const HBResp& rhs) const; +#ifndef SWIG + friend bool operator>(const HBResp& __x, const HBResp& __y) { + return __y < __x; + } + friend bool operator<=(const HBResp& __x, const HBResp& __y) { + return !(__y < __x); + } + friend bool operator>=(const HBResp& __x, const HBResp& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() const& { + return {this->code, __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() const&& { + return {std::move(this->code), __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() & { + return {this->code, __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() && { + return {std::move(this->code), __isset.code}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() const& { + return {this->leader, __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() const&& { + return {std::move(this->leader), __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() & { + return {this->leader, __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() && { + return {std::move(this->leader), __isset.leader}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref cluster_id_ref() const& { + return {this->cluster_id, __isset.cluster_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref cluster_id_ref() const&& { + return {std::move(this->cluster_id), __isset.cluster_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref cluster_id_ref() & { + return {this->cluster_id, __isset.cluster_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref cluster_id_ref() && { + return {std::move(this->cluster_id), __isset.cluster_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref last_update_time_in_ms_ref() const& { + return {this->last_update_time_in_ms, __isset.last_update_time_in_ms}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref last_update_time_in_ms_ref() const&& { + return {std::move(this->last_update_time_in_ms), __isset.last_update_time_in_ms}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref last_update_time_in_ms_ref() & { + return {this->last_update_time_in_ms, __isset.last_update_time_in_ms}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref last_update_time_in_ms_ref() && { + return {std::move(this->last_update_time_in_ms), __isset.last_update_time_in_ms}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref meta_version_ref() const& { + return {this->meta_version, __isset.meta_version}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref meta_version_ref() const&& { + return {std::move(this->meta_version), __isset.meta_version}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref meta_version_ref() & { + return {this->meta_version, __isset.meta_version}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref meta_version_ref() && { + return {std::move(this->meta_version), __isset.meta_version}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::ErrorCode get_code() const { + return code; + } + + ::nebula::cpp2::ErrorCode& set_code( ::nebula::cpp2::ErrorCode code_) { + code = code_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.code = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return code; + } + const nebula::HostAddr& get_leader() const&; + nebula::HostAddr get_leader() &&; + + template + nebula::HostAddr& set_leader(T_HBResp_leader_struct_setter&& leader_) { + leader = std::forward(leader_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.leader = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return leader; + } + + ::nebula::meta::cpp2::ClusterID get_cluster_id() const { + return cluster_id; + } + + ::nebula::meta::cpp2::ClusterID& set_cluster_id( ::nebula::meta::cpp2::ClusterID cluster_id_) { + cluster_id = cluster_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.cluster_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return cluster_id; + } + + int64_t get_last_update_time_in_ms() const { + return last_update_time_in_ms; + } + + int64_t& set_last_update_time_in_ms(int64_t last_update_time_in_ms_) { + last_update_time_in_ms = last_update_time_in_ms_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.last_update_time_in_ms = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return last_update_time_in_ms; + } + + int32_t get_meta_version() const { + return meta_version; + } + + int32_t& set_meta_version(int32_t meta_version_) { + meta_version = meta_version_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.meta_version = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return meta_version; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< HBResp >; + friend void swap(HBResp& a, HBResp& b); +}; + +template +uint32_t HBResp::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class LeaderInfo final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = LeaderInfo; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + LeaderInfo() : + part_id(0), + term(0) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + LeaderInfo(apache::thrift::FragileConstructor, ::nebula::cpp2::PartitionID part_id__arg, int64_t term__arg); + + LeaderInfo(LeaderInfo&&) = default; + + LeaderInfo(const LeaderInfo&) = default; + + + LeaderInfo& operator=(LeaderInfo&&) = default; + + LeaderInfo& operator=(const LeaderInfo&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::PartitionID part_id; + private: + int64_t term; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool part_id; + bool term; + } __isset = {}; + bool operator==(const LeaderInfo& rhs) const; +#ifndef SWIG + friend bool operator!=(const LeaderInfo& __x, const LeaderInfo& __y) { + return !(__x == __y); + } +#endif + bool operator<(const LeaderInfo& rhs) const; +#ifndef SWIG + friend bool operator>(const LeaderInfo& __x, const LeaderInfo& __y) { + return __y < __x; + } + friend bool operator<=(const LeaderInfo& __x, const LeaderInfo& __y) { + return !(__y < __x); + } + friend bool operator>=(const LeaderInfo& __x, const LeaderInfo& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref part_id_ref() const& { + return {this->part_id, __isset.part_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref part_id_ref() const&& { + return {std::move(this->part_id), __isset.part_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref part_id_ref() & { + return {this->part_id, __isset.part_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref part_id_ref() && { + return {std::move(this->part_id), __isset.part_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref term_ref() const& { + return {this->term, __isset.term}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref term_ref() const&& { + return {std::move(this->term), __isset.term}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref term_ref() & { + return {this->term, __isset.term}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref term_ref() && { + return {std::move(this->term), __isset.term}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::PartitionID get_part_id() const { + return part_id; + } + + ::nebula::cpp2::PartitionID& set_part_id( ::nebula::cpp2::PartitionID part_id_) { + part_id = part_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.part_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return part_id; + } + + int64_t get_term() const { + return term; + } + + int64_t& set_term(int64_t term_) { + term = term_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.term = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return term; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< LeaderInfo >; + friend void swap(LeaderInfo& a, LeaderInfo& b); +}; + +template +uint32_t LeaderInfo::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class HBReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = HBReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + + HBReq(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + HBReq(apache::thrift::FragileConstructor, ::nebula::meta::cpp2::HostRole role__arg, nebula::HostAddr host__arg, ::nebula::meta::cpp2::ClusterID cluster_id__arg, std::unordered_map< ::nebula::cpp2::GraphSpaceID, ::std::vector< ::nebula::meta::cpp2::LeaderInfo>> leader_partIds__arg, ::std::string git_info_sha__arg, ::std::string version__arg); + + HBReq(HBReq&&) = default; + + HBReq(const HBReq&) = default; + + + HBReq& operator=(HBReq&&) = default; + + HBReq& operator=(const HBReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + + ~HBReq(); + + private: + ::nebula::meta::cpp2::HostRole role; + private: + nebula::HostAddr host; + private: + ::nebula::meta::cpp2::ClusterID cluster_id; + private: + std::unordered_map< ::nebula::cpp2::GraphSpaceID, ::std::vector< ::nebula::meta::cpp2::LeaderInfo>> leader_partIds; + private: + ::std::string git_info_sha; + private: + ::std::string version; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool role; + bool host; + bool cluster_id; + bool leader_partIds; + bool git_info_sha; + bool version; + } __isset = {}; + bool operator==(const HBReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const HBReq& __x, const HBReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const HBReq& rhs) const; +#ifndef SWIG + friend bool operator>(const HBReq& __x, const HBReq& __y) { + return __y < __x; + } + friend bool operator<=(const HBReq& __x, const HBReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const HBReq& __x, const HBReq& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref role_ref() const& { + return {this->role, __isset.role}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref role_ref() const&& { + return {std::move(this->role), __isset.role}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref role_ref() & { + return {this->role, __isset.role}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref role_ref() && { + return {std::move(this->role), __isset.role}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref host_ref() const& { + return {this->host, __isset.host}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref host_ref() const&& { + return {std::move(this->host), __isset.host}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref host_ref() & { + return {this->host, __isset.host}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref host_ref() && { + return {std::move(this->host), __isset.host}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref cluster_id_ref() const& { + return {this->cluster_id, __isset.cluster_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref cluster_id_ref() const&& { + return {std::move(this->cluster_id), __isset.cluster_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref cluster_id_ref() & { + return {this->cluster_id, __isset.cluster_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref cluster_id_ref() && { + return {std::move(this->cluster_id), __isset.cluster_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template >> + FOLLY_ERASE ::apache::thrift::optional_field_ref leader_partIds_ref() const& { + return {this->leader_partIds, __isset.leader_partIds}; + } + + template >> + FOLLY_ERASE ::apache::thrift::optional_field_ref leader_partIds_ref() const&& { + return {std::move(this->leader_partIds), __isset.leader_partIds}; + } + + template >> + FOLLY_ERASE ::apache::thrift::optional_field_ref leader_partIds_ref() & { + return {this->leader_partIds, __isset.leader_partIds}; + } + + template >> + FOLLY_ERASE ::apache::thrift::optional_field_ref leader_partIds_ref() && { + return {std::move(this->leader_partIds), __isset.leader_partIds}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref git_info_sha_ref() const& { + return {this->git_info_sha, __isset.git_info_sha}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref git_info_sha_ref() const&& { + return {std::move(this->git_info_sha), __isset.git_info_sha}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref git_info_sha_ref() & { + return {this->git_info_sha, __isset.git_info_sha}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref git_info_sha_ref() && { + return {std::move(this->git_info_sha), __isset.git_info_sha}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::optional_field_ref version_ref() const& { + return {this->version, __isset.version}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref version_ref() const&& { + return {std::move(this->version), __isset.version}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref version_ref() & { + return {this->version, __isset.version}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref version_ref() && { + return {std::move(this->version), __isset.version}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::meta::cpp2::HostRole get_role() const { + return role; + } + + ::nebula::meta::cpp2::HostRole& set_role( ::nebula::meta::cpp2::HostRole role_) { + role = role_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.role = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return role; + } + const nebula::HostAddr& get_host() const&; + nebula::HostAddr get_host() &&; + + template + nebula::HostAddr& set_host(T_HBReq_host_struct_setter&& host_) { + host = std::forward(host_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.host = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return host; + } + + ::nebula::meta::cpp2::ClusterID get_cluster_id() const { + return cluster_id; + } + + ::nebula::meta::cpp2::ClusterID& set_cluster_id( ::nebula::meta::cpp2::ClusterID cluster_id_) { + cluster_id = cluster_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.cluster_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return cluster_id; + } + const std::unordered_map< ::nebula::cpp2::GraphSpaceID, ::std::vector< ::nebula::meta::cpp2::LeaderInfo>>* get_leader_partIds() const&; + std::unordered_map< ::nebula::cpp2::GraphSpaceID, ::std::vector< ::nebula::meta::cpp2::LeaderInfo>>* get_leader_partIds() &; + std::unordered_map< ::nebula::cpp2::GraphSpaceID, ::std::vector< ::nebula::meta::cpp2::LeaderInfo>>* get_leader_partIds() && = delete; + + template >> + std::unordered_map< ::nebula::cpp2::GraphSpaceID, ::std::vector< ::nebula::meta::cpp2::LeaderInfo>>& set_leader_partIds(T_HBReq_leader_partIds_struct_setter&& leader_partIds_) { + leader_partIds = std::forward(leader_partIds_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.leader_partIds = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return leader_partIds; + } + + const ::std::string& get_git_info_sha() const& { + return git_info_sha; + } + + ::std::string get_git_info_sha() && { + return std::move(git_info_sha); + } + + template + ::std::string& set_git_info_sha(T_HBReq_git_info_sha_struct_setter&& git_info_sha_) { + git_info_sha = std::forward(git_info_sha_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.git_info_sha = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return git_info_sha; + } + + const ::std::string* get_version() const& { + return version_ref() ? std::addressof(version) : nullptr; + } + + ::std::string* get_version() & { + return version_ref() ? std::addressof(version) : nullptr; + } + ::std::string* get_version() && = delete; + + template + ::std::string& set_version(T_HBReq_version_struct_setter&& version_) { + version = std::forward(version_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.version = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return version; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< HBReq >; + friend void swap(HBReq& a, HBReq& b); +}; + +template +uint32_t HBReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class IndexFieldDef final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = IndexFieldDef; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + IndexFieldDef() : + type_length(0) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + IndexFieldDef(apache::thrift::FragileConstructor, ::std::string name__arg, int16_t type_length__arg); + + IndexFieldDef(IndexFieldDef&&) = default; + + IndexFieldDef(const IndexFieldDef&) = default; + + + IndexFieldDef& operator=(IndexFieldDef&&) = default; + + IndexFieldDef& operator=(const IndexFieldDef&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + public: + ::std::string name; + private: + int16_t type_length; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool type_length; + } __isset = {}; + bool operator==(const IndexFieldDef& rhs) const; +#ifndef SWIG + friend bool operator!=(const IndexFieldDef& __x, const IndexFieldDef& __y) { + return !(__x == __y); + } +#endif + bool operator<(const IndexFieldDef& rhs) const; +#ifndef SWIG + friend bool operator>(const IndexFieldDef& __x, const IndexFieldDef& __y) { + return __y < __x; + } + friend bool operator<=(const IndexFieldDef& __x, const IndexFieldDef& __y) { + return !(__y < __x); + } + friend bool operator>=(const IndexFieldDef& __x, const IndexFieldDef& __y) { + return !(__x < __y); + } +#endif + template + FOLLY_ERASE ::apache::thrift::required_field_ref name_ref() const& { + return ::apache::thrift::required_field_ref{this->name}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref name_ref() const&& { + return ::apache::thrift::required_field_ref{std::move(this->name)}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref name_ref() & { + return ::apache::thrift::required_field_ref{this->name}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref name_ref() && { + return ::apache::thrift::required_field_ref{std::move(this->name)}; + } + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::optional_field_ref type_length_ref() const& { + return {this->type_length, __isset.type_length}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref type_length_ref() const&& { + return {std::move(this->type_length), __isset.type_length}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref type_length_ref() & { + return {this->type_length, __isset.type_length}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref type_length_ref() && { + return {std::move(this->type_length), __isset.type_length}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + const ::std::string& get_name() const& { + return name; + } + + ::std::string get_name() && { + return std::move(name); + } + + template + ::std::string& set_name(T_IndexFieldDef_name_struct_setter&& name_) { + name = std::forward(name_); + return name; + } + + const int16_t* get_type_length() const& { + return type_length_ref() ? std::addressof(type_length) : nullptr; + } + + int16_t* get_type_length() & { + return type_length_ref() ? std::addressof(type_length) : nullptr; + } + int16_t* get_type_length() && = delete; + + int16_t& set_type_length(int16_t type_length_) { + type_length = type_length_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.type_length = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return type_length; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< IndexFieldDef >; + friend void swap(IndexFieldDef& a, IndexFieldDef& b); +}; + +template +uint32_t IndexFieldDef::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class CreateTagIndexReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = CreateTagIndexReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + + CreateTagIndexReq(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + CreateTagIndexReq(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, ::std::string index_name__arg, ::std::string tag_name__arg, ::std::vector< ::nebula::meta::cpp2::IndexFieldDef> fields__arg, bool if_not_exists__arg, ::std::string comment__arg); + + CreateTagIndexReq(CreateTagIndexReq&&) = default; + + CreateTagIndexReq(const CreateTagIndexReq&) = default; + + + CreateTagIndexReq& operator=(CreateTagIndexReq&&) = default; + + CreateTagIndexReq& operator=(const CreateTagIndexReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + + ~CreateTagIndexReq(); + + private: + ::nebula::cpp2::GraphSpaceID space_id; + private: + ::std::string index_name; + private: + ::std::string tag_name; + private: + ::std::vector< ::nebula::meta::cpp2::IndexFieldDef> fields; + private: + bool if_not_exists; + private: + ::std::string comment; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool space_id; + bool index_name; + bool tag_name; + bool fields; + bool if_not_exists; + bool comment; + } __isset = {}; + bool operator==(const CreateTagIndexReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const CreateTagIndexReq& __x, const CreateTagIndexReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const CreateTagIndexReq& rhs) const; +#ifndef SWIG + friend bool operator>(const CreateTagIndexReq& __x, const CreateTagIndexReq& __y) { + return __y < __x; + } + friend bool operator<=(const CreateTagIndexReq& __x, const CreateTagIndexReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const CreateTagIndexReq& __x, const CreateTagIndexReq& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const& { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const&& { + return {std::move(this->space_id), __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() & { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() && { + return {std::move(this->space_id), __isset.space_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref index_name_ref() const& { + return {this->index_name, __isset.index_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref index_name_ref() const&& { + return {std::move(this->index_name), __isset.index_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref index_name_ref() & { + return {this->index_name, __isset.index_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref index_name_ref() && { + return {std::move(this->index_name), __isset.index_name}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref tag_name_ref() const& { + return {this->tag_name, __isset.tag_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref tag_name_ref() const&& { + return {std::move(this->tag_name), __isset.tag_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref tag_name_ref() & { + return {this->tag_name, __isset.tag_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref tag_name_ref() && { + return {std::move(this->tag_name), __isset.tag_name}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::field_ref fields_ref() const& { + return {this->fields, __isset.fields}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref fields_ref() const&& { + return {std::move(this->fields), __isset.fields}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref fields_ref() & { + return {this->fields, __isset.fields}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref fields_ref() && { + return {std::move(this->fields), __isset.fields}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref if_not_exists_ref() const& { + return {this->if_not_exists, __isset.if_not_exists}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref if_not_exists_ref() const&& { + return {std::move(this->if_not_exists), __isset.if_not_exists}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref if_not_exists_ref() & { + return {this->if_not_exists, __isset.if_not_exists}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref if_not_exists_ref() && { + return {std::move(this->if_not_exists), __isset.if_not_exists}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::optional_field_ref comment_ref() const& { + return {this->comment, __isset.comment}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref comment_ref() const&& { + return {std::move(this->comment), __isset.comment}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref comment_ref() & { + return {this->comment, __isset.comment}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref comment_ref() && { + return {std::move(this->comment), __isset.comment}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::GraphSpaceID get_space_id() const { + return space_id; + } + + ::nebula::cpp2::GraphSpaceID& set_space_id( ::nebula::cpp2::GraphSpaceID space_id_) { + space_id = space_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.space_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return space_id; + } + + const ::std::string& get_index_name() const& { + return index_name; + } + + ::std::string get_index_name() && { + return std::move(index_name); + } + + template + ::std::string& set_index_name(T_CreateTagIndexReq_index_name_struct_setter&& index_name_) { + index_name = std::forward(index_name_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.index_name = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return index_name; + } + + const ::std::string& get_tag_name() const& { + return tag_name; + } + + ::std::string get_tag_name() && { + return std::move(tag_name); + } + + template + ::std::string& set_tag_name(T_CreateTagIndexReq_tag_name_struct_setter&& tag_name_) { + tag_name = std::forward(tag_name_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.tag_name = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return tag_name; + } + const ::std::vector< ::nebula::meta::cpp2::IndexFieldDef>& get_fields() const&; + ::std::vector< ::nebula::meta::cpp2::IndexFieldDef> get_fields() &&; + + template > + ::std::vector< ::nebula::meta::cpp2::IndexFieldDef>& set_fields(T_CreateTagIndexReq_fields_struct_setter&& fields_) { + fields = std::forward(fields_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.fields = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return fields; + } + + bool get_if_not_exists() const { + return if_not_exists; + } + + bool& set_if_not_exists(bool if_not_exists_) { + if_not_exists = if_not_exists_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.if_not_exists = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return if_not_exists; + } + + const ::std::string* get_comment() const& { + return comment_ref() ? std::addressof(comment) : nullptr; + } + + ::std::string* get_comment() & { + return comment_ref() ? std::addressof(comment) : nullptr; + } + ::std::string* get_comment() && = delete; + + template + ::std::string& set_comment(T_CreateTagIndexReq_comment_struct_setter&& comment_) { + comment = std::forward(comment_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.comment = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return comment; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< CreateTagIndexReq >; + friend void swap(CreateTagIndexReq& a, CreateTagIndexReq& b); +}; + +template +uint32_t CreateTagIndexReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class DropTagIndexReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = DropTagIndexReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + DropTagIndexReq() : + space_id(0), + if_exists(0) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + DropTagIndexReq(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, ::std::string index_name__arg, bool if_exists__arg); + + DropTagIndexReq(DropTagIndexReq&&) = default; + + DropTagIndexReq(const DropTagIndexReq&) = default; + + + DropTagIndexReq& operator=(DropTagIndexReq&&) = default; + + DropTagIndexReq& operator=(const DropTagIndexReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::GraphSpaceID space_id; + private: + ::std::string index_name; + private: + bool if_exists; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool space_id; + bool index_name; + bool if_exists; + } __isset = {}; + bool operator==(const DropTagIndexReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const DropTagIndexReq& __x, const DropTagIndexReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const DropTagIndexReq& rhs) const; +#ifndef SWIG + friend bool operator>(const DropTagIndexReq& __x, const DropTagIndexReq& __y) { + return __y < __x; + } + friend bool operator<=(const DropTagIndexReq& __x, const DropTagIndexReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const DropTagIndexReq& __x, const DropTagIndexReq& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const& { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const&& { + return {std::move(this->space_id), __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() & { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() && { + return {std::move(this->space_id), __isset.space_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref index_name_ref() const& { + return {this->index_name, __isset.index_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref index_name_ref() const&& { + return {std::move(this->index_name), __isset.index_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref index_name_ref() & { + return {this->index_name, __isset.index_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref index_name_ref() && { + return {std::move(this->index_name), __isset.index_name}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref if_exists_ref() const& { + return {this->if_exists, __isset.if_exists}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref if_exists_ref() const&& { + return {std::move(this->if_exists), __isset.if_exists}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref if_exists_ref() & { + return {this->if_exists, __isset.if_exists}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref if_exists_ref() && { + return {std::move(this->if_exists), __isset.if_exists}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::GraphSpaceID get_space_id() const { + return space_id; + } + + ::nebula::cpp2::GraphSpaceID& set_space_id( ::nebula::cpp2::GraphSpaceID space_id_) { + space_id = space_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.space_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return space_id; + } + + const ::std::string& get_index_name() const& { + return index_name; + } + + ::std::string get_index_name() && { + return std::move(index_name); + } + + template + ::std::string& set_index_name(T_DropTagIndexReq_index_name_struct_setter&& index_name_) { + index_name = std::forward(index_name_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.index_name = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return index_name; + } + + bool get_if_exists() const { + return if_exists; + } + + bool& set_if_exists(bool if_exists_) { + if_exists = if_exists_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.if_exists = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return if_exists; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< DropTagIndexReq >; + friend void swap(DropTagIndexReq& a, DropTagIndexReq& b); +}; + +template +uint32_t DropTagIndexReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class GetTagIndexReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = GetTagIndexReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + GetTagIndexReq() : + space_id(0) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + GetTagIndexReq(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, ::std::string index_name__arg); + + GetTagIndexReq(GetTagIndexReq&&) = default; + + GetTagIndexReq(const GetTagIndexReq&) = default; + + + GetTagIndexReq& operator=(GetTagIndexReq&&) = default; + + GetTagIndexReq& operator=(const GetTagIndexReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::GraphSpaceID space_id; + private: + ::std::string index_name; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool space_id; + bool index_name; + } __isset = {}; + bool operator==(const GetTagIndexReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const GetTagIndexReq& __x, const GetTagIndexReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const GetTagIndexReq& rhs) const; +#ifndef SWIG + friend bool operator>(const GetTagIndexReq& __x, const GetTagIndexReq& __y) { + return __y < __x; + } + friend bool operator<=(const GetTagIndexReq& __x, const GetTagIndexReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const GetTagIndexReq& __x, const GetTagIndexReq& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const& { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const&& { + return {std::move(this->space_id), __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() & { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() && { + return {std::move(this->space_id), __isset.space_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref index_name_ref() const& { + return {this->index_name, __isset.index_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref index_name_ref() const&& { + return {std::move(this->index_name), __isset.index_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref index_name_ref() & { + return {this->index_name, __isset.index_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref index_name_ref() && { + return {std::move(this->index_name), __isset.index_name}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::GraphSpaceID get_space_id() const { + return space_id; + } + + ::nebula::cpp2::GraphSpaceID& set_space_id( ::nebula::cpp2::GraphSpaceID space_id_) { + space_id = space_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.space_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return space_id; + } + + const ::std::string& get_index_name() const& { + return index_name; + } + + ::std::string get_index_name() && { + return std::move(index_name); + } + + template + ::std::string& set_index_name(T_GetTagIndexReq_index_name_struct_setter&& index_name_) { + index_name = std::forward(index_name_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.index_name = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return index_name; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< GetTagIndexReq >; + friend void swap(GetTagIndexReq& a, GetTagIndexReq& b); +}; + +template +uint32_t GetTagIndexReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class GetTagIndexResp final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = GetTagIndexResp; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + GetTagIndexResp() : + code( ::nebula::cpp2::ErrorCode::SUCCEEDED) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + GetTagIndexResp(apache::thrift::FragileConstructor, ::nebula::cpp2::ErrorCode code__arg, nebula::HostAddr leader__arg, ::nebula::meta::cpp2::IndexItem item__arg); + + GetTagIndexResp(GetTagIndexResp&&) = default; + + GetTagIndexResp(const GetTagIndexResp&) = default; + + + GetTagIndexResp& operator=(GetTagIndexResp&&) = default; + + GetTagIndexResp& operator=(const GetTagIndexResp&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::ErrorCode code; + private: + nebula::HostAddr leader; + private: + ::nebula::meta::cpp2::IndexItem item; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool code; + bool leader; + bool item; + } __isset = {}; + bool operator==(const GetTagIndexResp& rhs) const; +#ifndef SWIG + friend bool operator!=(const GetTagIndexResp& __x, const GetTagIndexResp& __y) { + return !(__x == __y); + } +#endif + bool operator<(const GetTagIndexResp& rhs) const; +#ifndef SWIG + friend bool operator>(const GetTagIndexResp& __x, const GetTagIndexResp& __y) { + return __y < __x; + } + friend bool operator<=(const GetTagIndexResp& __x, const GetTagIndexResp& __y) { + return !(__y < __x); + } + friend bool operator>=(const GetTagIndexResp& __x, const GetTagIndexResp& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() const& { + return {this->code, __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() const&& { + return {std::move(this->code), __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() & { + return {this->code, __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() && { + return {std::move(this->code), __isset.code}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() const& { + return {this->leader, __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() const&& { + return {std::move(this->leader), __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() & { + return {this->leader, __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() && { + return {std::move(this->leader), __isset.leader}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref item_ref() const& { + return {this->item, __isset.item}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref item_ref() const&& { + return {std::move(this->item), __isset.item}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref item_ref() & { + return {this->item, __isset.item}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref item_ref() && { + return {std::move(this->item), __isset.item}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::ErrorCode get_code() const { + return code; + } + + ::nebula::cpp2::ErrorCode& set_code( ::nebula::cpp2::ErrorCode code_) { + code = code_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.code = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return code; + } + const nebula::HostAddr& get_leader() const&; + nebula::HostAddr get_leader() &&; + + template + nebula::HostAddr& set_leader(T_GetTagIndexResp_leader_struct_setter&& leader_) { + leader = std::forward(leader_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.leader = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return leader; + } + const ::nebula::meta::cpp2::IndexItem& get_item() const&; + ::nebula::meta::cpp2::IndexItem get_item() &&; + + template + ::nebula::meta::cpp2::IndexItem& set_item(T_GetTagIndexResp_item_struct_setter&& item_) { + item = std::forward(item_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.item = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return item; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< GetTagIndexResp >; + friend void swap(GetTagIndexResp& a, GetTagIndexResp& b); +}; + +template +uint32_t GetTagIndexResp::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class ListTagIndexesReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = ListTagIndexesReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + ListTagIndexesReq() : + space_id(0) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + ListTagIndexesReq(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg); + + ListTagIndexesReq(ListTagIndexesReq&&) = default; + + ListTagIndexesReq(const ListTagIndexesReq&) = default; + + + ListTagIndexesReq& operator=(ListTagIndexesReq&&) = default; + + ListTagIndexesReq& operator=(const ListTagIndexesReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::GraphSpaceID space_id; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool space_id; + } __isset = {}; + bool operator==(const ListTagIndexesReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const ListTagIndexesReq& __x, const ListTagIndexesReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const ListTagIndexesReq& rhs) const; +#ifndef SWIG + friend bool operator>(const ListTagIndexesReq& __x, const ListTagIndexesReq& __y) { + return __y < __x; + } + friend bool operator<=(const ListTagIndexesReq& __x, const ListTagIndexesReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const ListTagIndexesReq& __x, const ListTagIndexesReq& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const& { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const&& { + return {std::move(this->space_id), __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() & { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() && { + return {std::move(this->space_id), __isset.space_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::GraphSpaceID get_space_id() const { + return space_id; + } + + ::nebula::cpp2::GraphSpaceID& set_space_id( ::nebula::cpp2::GraphSpaceID space_id_) { + space_id = space_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.space_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return space_id; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< ListTagIndexesReq >; + friend void swap(ListTagIndexesReq& a, ListTagIndexesReq& b); +}; + +template +uint32_t ListTagIndexesReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class ListTagIndexesResp final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = ListTagIndexesResp; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + ListTagIndexesResp() : + code( ::nebula::cpp2::ErrorCode::SUCCEEDED) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + ListTagIndexesResp(apache::thrift::FragileConstructor, ::nebula::cpp2::ErrorCode code__arg, nebula::HostAddr leader__arg, ::std::vector< ::nebula::meta::cpp2::IndexItem> items__arg); + + ListTagIndexesResp(ListTagIndexesResp&&) = default; + + ListTagIndexesResp(const ListTagIndexesResp&) = default; + + + ListTagIndexesResp& operator=(ListTagIndexesResp&&) = default; + + ListTagIndexesResp& operator=(const ListTagIndexesResp&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::ErrorCode code; + private: + nebula::HostAddr leader; + private: + ::std::vector< ::nebula::meta::cpp2::IndexItem> items; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool code; + bool leader; + bool items; + } __isset = {}; + bool operator==(const ListTagIndexesResp& rhs) const; +#ifndef SWIG + friend bool operator!=(const ListTagIndexesResp& __x, const ListTagIndexesResp& __y) { + return !(__x == __y); + } +#endif + bool operator<(const ListTagIndexesResp& rhs) const; +#ifndef SWIG + friend bool operator>(const ListTagIndexesResp& __x, const ListTagIndexesResp& __y) { + return __y < __x; + } + friend bool operator<=(const ListTagIndexesResp& __x, const ListTagIndexesResp& __y) { + return !(__y < __x); + } + friend bool operator>=(const ListTagIndexesResp& __x, const ListTagIndexesResp& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() const& { + return {this->code, __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() const&& { + return {std::move(this->code), __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() & { + return {this->code, __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() && { + return {std::move(this->code), __isset.code}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() const& { + return {this->leader, __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() const&& { + return {std::move(this->leader), __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() & { + return {this->leader, __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() && { + return {std::move(this->leader), __isset.leader}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::field_ref items_ref() const& { + return {this->items, __isset.items}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref items_ref() const&& { + return {std::move(this->items), __isset.items}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref items_ref() & { + return {this->items, __isset.items}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref items_ref() && { + return {std::move(this->items), __isset.items}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::ErrorCode get_code() const { + return code; + } + + ::nebula::cpp2::ErrorCode& set_code( ::nebula::cpp2::ErrorCode code_) { + code = code_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.code = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return code; + } + const nebula::HostAddr& get_leader() const&; + nebula::HostAddr get_leader() &&; + + template + nebula::HostAddr& set_leader(T_ListTagIndexesResp_leader_struct_setter&& leader_) { + leader = std::forward(leader_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.leader = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return leader; + } + const ::std::vector< ::nebula::meta::cpp2::IndexItem>& get_items() const&; + ::std::vector< ::nebula::meta::cpp2::IndexItem> get_items() &&; + + template > + ::std::vector< ::nebula::meta::cpp2::IndexItem>& set_items(T_ListTagIndexesResp_items_struct_setter&& items_) { + items = std::forward(items_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.items = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return items; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< ListTagIndexesResp >; + friend void swap(ListTagIndexesResp& a, ListTagIndexesResp& b); +}; + +template +uint32_t ListTagIndexesResp::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class CreateEdgeIndexReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = CreateEdgeIndexReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + + CreateEdgeIndexReq(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + CreateEdgeIndexReq(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, ::std::string index_name__arg, ::std::string edge_name__arg, ::std::vector< ::nebula::meta::cpp2::IndexFieldDef> fields__arg, bool if_not_exists__arg, ::std::string comment__arg); + + CreateEdgeIndexReq(CreateEdgeIndexReq&&) = default; + + CreateEdgeIndexReq(const CreateEdgeIndexReq&) = default; + + + CreateEdgeIndexReq& operator=(CreateEdgeIndexReq&&) = default; + + CreateEdgeIndexReq& operator=(const CreateEdgeIndexReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + + ~CreateEdgeIndexReq(); + + private: + ::nebula::cpp2::GraphSpaceID space_id; + private: + ::std::string index_name; + private: + ::std::string edge_name; + private: + ::std::vector< ::nebula::meta::cpp2::IndexFieldDef> fields; + private: + bool if_not_exists; + private: + ::std::string comment; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool space_id; + bool index_name; + bool edge_name; + bool fields; + bool if_not_exists; + bool comment; + } __isset = {}; + bool operator==(const CreateEdgeIndexReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const CreateEdgeIndexReq& __x, const CreateEdgeIndexReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const CreateEdgeIndexReq& rhs) const; +#ifndef SWIG + friend bool operator>(const CreateEdgeIndexReq& __x, const CreateEdgeIndexReq& __y) { + return __y < __x; + } + friend bool operator<=(const CreateEdgeIndexReq& __x, const CreateEdgeIndexReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const CreateEdgeIndexReq& __x, const CreateEdgeIndexReq& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const& { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const&& { + return {std::move(this->space_id), __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() & { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() && { + return {std::move(this->space_id), __isset.space_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref index_name_ref() const& { + return {this->index_name, __isset.index_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref index_name_ref() const&& { + return {std::move(this->index_name), __isset.index_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref index_name_ref() & { + return {this->index_name, __isset.index_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref index_name_ref() && { + return {std::move(this->index_name), __isset.index_name}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref edge_name_ref() const& { + return {this->edge_name, __isset.edge_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref edge_name_ref() const&& { + return {std::move(this->edge_name), __isset.edge_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref edge_name_ref() & { + return {this->edge_name, __isset.edge_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref edge_name_ref() && { + return {std::move(this->edge_name), __isset.edge_name}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::field_ref fields_ref() const& { + return {this->fields, __isset.fields}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref fields_ref() const&& { + return {std::move(this->fields), __isset.fields}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref fields_ref() & { + return {this->fields, __isset.fields}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref fields_ref() && { + return {std::move(this->fields), __isset.fields}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref if_not_exists_ref() const& { + return {this->if_not_exists, __isset.if_not_exists}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref if_not_exists_ref() const&& { + return {std::move(this->if_not_exists), __isset.if_not_exists}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref if_not_exists_ref() & { + return {this->if_not_exists, __isset.if_not_exists}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref if_not_exists_ref() && { + return {std::move(this->if_not_exists), __isset.if_not_exists}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::optional_field_ref comment_ref() const& { + return {this->comment, __isset.comment}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref comment_ref() const&& { + return {std::move(this->comment), __isset.comment}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref comment_ref() & { + return {this->comment, __isset.comment}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref comment_ref() && { + return {std::move(this->comment), __isset.comment}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::GraphSpaceID get_space_id() const { + return space_id; + } + + ::nebula::cpp2::GraphSpaceID& set_space_id( ::nebula::cpp2::GraphSpaceID space_id_) { + space_id = space_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.space_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return space_id; + } + + const ::std::string& get_index_name() const& { + return index_name; + } + + ::std::string get_index_name() && { + return std::move(index_name); + } + + template + ::std::string& set_index_name(T_CreateEdgeIndexReq_index_name_struct_setter&& index_name_) { + index_name = std::forward(index_name_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.index_name = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return index_name; + } + + const ::std::string& get_edge_name() const& { + return edge_name; + } + + ::std::string get_edge_name() && { + return std::move(edge_name); + } + + template + ::std::string& set_edge_name(T_CreateEdgeIndexReq_edge_name_struct_setter&& edge_name_) { + edge_name = std::forward(edge_name_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.edge_name = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return edge_name; + } + const ::std::vector< ::nebula::meta::cpp2::IndexFieldDef>& get_fields() const&; + ::std::vector< ::nebula::meta::cpp2::IndexFieldDef> get_fields() &&; + + template > + ::std::vector< ::nebula::meta::cpp2::IndexFieldDef>& set_fields(T_CreateEdgeIndexReq_fields_struct_setter&& fields_) { + fields = std::forward(fields_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.fields = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return fields; + } + + bool get_if_not_exists() const { + return if_not_exists; + } + + bool& set_if_not_exists(bool if_not_exists_) { + if_not_exists = if_not_exists_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.if_not_exists = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return if_not_exists; + } + + const ::std::string* get_comment() const& { + return comment_ref() ? std::addressof(comment) : nullptr; + } + + ::std::string* get_comment() & { + return comment_ref() ? std::addressof(comment) : nullptr; + } + ::std::string* get_comment() && = delete; + + template + ::std::string& set_comment(T_CreateEdgeIndexReq_comment_struct_setter&& comment_) { + comment = std::forward(comment_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.comment = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return comment; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< CreateEdgeIndexReq >; + friend void swap(CreateEdgeIndexReq& a, CreateEdgeIndexReq& b); +}; + +template +uint32_t CreateEdgeIndexReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class DropEdgeIndexReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = DropEdgeIndexReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + DropEdgeIndexReq() : + space_id(0), + if_exists(0) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + DropEdgeIndexReq(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, ::std::string index_name__arg, bool if_exists__arg); + + DropEdgeIndexReq(DropEdgeIndexReq&&) = default; + + DropEdgeIndexReq(const DropEdgeIndexReq&) = default; + + + DropEdgeIndexReq& operator=(DropEdgeIndexReq&&) = default; + + DropEdgeIndexReq& operator=(const DropEdgeIndexReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::GraphSpaceID space_id; + private: + ::std::string index_name; + private: + bool if_exists; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool space_id; + bool index_name; + bool if_exists; + } __isset = {}; + bool operator==(const DropEdgeIndexReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const DropEdgeIndexReq& __x, const DropEdgeIndexReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const DropEdgeIndexReq& rhs) const; +#ifndef SWIG + friend bool operator>(const DropEdgeIndexReq& __x, const DropEdgeIndexReq& __y) { + return __y < __x; + } + friend bool operator<=(const DropEdgeIndexReq& __x, const DropEdgeIndexReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const DropEdgeIndexReq& __x, const DropEdgeIndexReq& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const& { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const&& { + return {std::move(this->space_id), __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() & { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() && { + return {std::move(this->space_id), __isset.space_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref index_name_ref() const& { + return {this->index_name, __isset.index_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref index_name_ref() const&& { + return {std::move(this->index_name), __isset.index_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref index_name_ref() & { + return {this->index_name, __isset.index_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref index_name_ref() && { + return {std::move(this->index_name), __isset.index_name}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref if_exists_ref() const& { + return {this->if_exists, __isset.if_exists}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref if_exists_ref() const&& { + return {std::move(this->if_exists), __isset.if_exists}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref if_exists_ref() & { + return {this->if_exists, __isset.if_exists}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref if_exists_ref() && { + return {std::move(this->if_exists), __isset.if_exists}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::GraphSpaceID get_space_id() const { + return space_id; + } + + ::nebula::cpp2::GraphSpaceID& set_space_id( ::nebula::cpp2::GraphSpaceID space_id_) { + space_id = space_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.space_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return space_id; + } + + const ::std::string& get_index_name() const& { + return index_name; + } + + ::std::string get_index_name() && { + return std::move(index_name); + } + + template + ::std::string& set_index_name(T_DropEdgeIndexReq_index_name_struct_setter&& index_name_) { + index_name = std::forward(index_name_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.index_name = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return index_name; + } + + bool get_if_exists() const { + return if_exists; + } + + bool& set_if_exists(bool if_exists_) { + if_exists = if_exists_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.if_exists = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return if_exists; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< DropEdgeIndexReq >; + friend void swap(DropEdgeIndexReq& a, DropEdgeIndexReq& b); +}; + +template +uint32_t DropEdgeIndexReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class GetEdgeIndexReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = GetEdgeIndexReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + GetEdgeIndexReq() : + space_id(0) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + GetEdgeIndexReq(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, ::std::string index_name__arg); + + GetEdgeIndexReq(GetEdgeIndexReq&&) = default; + + GetEdgeIndexReq(const GetEdgeIndexReq&) = default; + + + GetEdgeIndexReq& operator=(GetEdgeIndexReq&&) = default; + + GetEdgeIndexReq& operator=(const GetEdgeIndexReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::GraphSpaceID space_id; + private: + ::std::string index_name; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool space_id; + bool index_name; + } __isset = {}; + bool operator==(const GetEdgeIndexReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const GetEdgeIndexReq& __x, const GetEdgeIndexReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const GetEdgeIndexReq& rhs) const; +#ifndef SWIG + friend bool operator>(const GetEdgeIndexReq& __x, const GetEdgeIndexReq& __y) { + return __y < __x; + } + friend bool operator<=(const GetEdgeIndexReq& __x, const GetEdgeIndexReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const GetEdgeIndexReq& __x, const GetEdgeIndexReq& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const& { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const&& { + return {std::move(this->space_id), __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() & { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() && { + return {std::move(this->space_id), __isset.space_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref index_name_ref() const& { + return {this->index_name, __isset.index_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref index_name_ref() const&& { + return {std::move(this->index_name), __isset.index_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref index_name_ref() & { + return {this->index_name, __isset.index_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref index_name_ref() && { + return {std::move(this->index_name), __isset.index_name}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::GraphSpaceID get_space_id() const { + return space_id; + } + + ::nebula::cpp2::GraphSpaceID& set_space_id( ::nebula::cpp2::GraphSpaceID space_id_) { + space_id = space_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.space_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return space_id; + } + + const ::std::string& get_index_name() const& { + return index_name; + } + + ::std::string get_index_name() && { + return std::move(index_name); + } + + template + ::std::string& set_index_name(T_GetEdgeIndexReq_index_name_struct_setter&& index_name_) { + index_name = std::forward(index_name_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.index_name = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return index_name; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< GetEdgeIndexReq >; + friend void swap(GetEdgeIndexReq& a, GetEdgeIndexReq& b); +}; + +template +uint32_t GetEdgeIndexReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class GetEdgeIndexResp final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = GetEdgeIndexResp; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + GetEdgeIndexResp() : + code( ::nebula::cpp2::ErrorCode::SUCCEEDED) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + GetEdgeIndexResp(apache::thrift::FragileConstructor, ::nebula::cpp2::ErrorCode code__arg, nebula::HostAddr leader__arg, ::nebula::meta::cpp2::IndexItem item__arg); + + GetEdgeIndexResp(GetEdgeIndexResp&&) = default; + + GetEdgeIndexResp(const GetEdgeIndexResp&) = default; + + + GetEdgeIndexResp& operator=(GetEdgeIndexResp&&) = default; + + GetEdgeIndexResp& operator=(const GetEdgeIndexResp&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::ErrorCode code; + private: + nebula::HostAddr leader; + private: + ::nebula::meta::cpp2::IndexItem item; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool code; + bool leader; + bool item; + } __isset = {}; + bool operator==(const GetEdgeIndexResp& rhs) const; +#ifndef SWIG + friend bool operator!=(const GetEdgeIndexResp& __x, const GetEdgeIndexResp& __y) { + return !(__x == __y); + } +#endif + bool operator<(const GetEdgeIndexResp& rhs) const; +#ifndef SWIG + friend bool operator>(const GetEdgeIndexResp& __x, const GetEdgeIndexResp& __y) { + return __y < __x; + } + friend bool operator<=(const GetEdgeIndexResp& __x, const GetEdgeIndexResp& __y) { + return !(__y < __x); + } + friend bool operator>=(const GetEdgeIndexResp& __x, const GetEdgeIndexResp& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() const& { + return {this->code, __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() const&& { + return {std::move(this->code), __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() & { + return {this->code, __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() && { + return {std::move(this->code), __isset.code}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() const& { + return {this->leader, __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() const&& { + return {std::move(this->leader), __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() & { + return {this->leader, __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() && { + return {std::move(this->leader), __isset.leader}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref item_ref() const& { + return {this->item, __isset.item}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref item_ref() const&& { + return {std::move(this->item), __isset.item}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref item_ref() & { + return {this->item, __isset.item}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref item_ref() && { + return {std::move(this->item), __isset.item}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::ErrorCode get_code() const { + return code; + } + + ::nebula::cpp2::ErrorCode& set_code( ::nebula::cpp2::ErrorCode code_) { + code = code_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.code = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return code; + } + const nebula::HostAddr& get_leader() const&; + nebula::HostAddr get_leader() &&; + + template + nebula::HostAddr& set_leader(T_GetEdgeIndexResp_leader_struct_setter&& leader_) { + leader = std::forward(leader_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.leader = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return leader; + } + const ::nebula::meta::cpp2::IndexItem& get_item() const&; + ::nebula::meta::cpp2::IndexItem get_item() &&; + + template + ::nebula::meta::cpp2::IndexItem& set_item(T_GetEdgeIndexResp_item_struct_setter&& item_) { + item = std::forward(item_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.item = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return item; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< GetEdgeIndexResp >; + friend void swap(GetEdgeIndexResp& a, GetEdgeIndexResp& b); +}; + +template +uint32_t GetEdgeIndexResp::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class ListEdgeIndexesReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = ListEdgeIndexesReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + ListEdgeIndexesReq() : + space_id(0) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + ListEdgeIndexesReq(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg); + + ListEdgeIndexesReq(ListEdgeIndexesReq&&) = default; + + ListEdgeIndexesReq(const ListEdgeIndexesReq&) = default; + + + ListEdgeIndexesReq& operator=(ListEdgeIndexesReq&&) = default; + + ListEdgeIndexesReq& operator=(const ListEdgeIndexesReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::GraphSpaceID space_id; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool space_id; + } __isset = {}; + bool operator==(const ListEdgeIndexesReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const ListEdgeIndexesReq& __x, const ListEdgeIndexesReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const ListEdgeIndexesReq& rhs) const; +#ifndef SWIG + friend bool operator>(const ListEdgeIndexesReq& __x, const ListEdgeIndexesReq& __y) { + return __y < __x; + } + friend bool operator<=(const ListEdgeIndexesReq& __x, const ListEdgeIndexesReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const ListEdgeIndexesReq& __x, const ListEdgeIndexesReq& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const& { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const&& { + return {std::move(this->space_id), __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() & { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() && { + return {std::move(this->space_id), __isset.space_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::GraphSpaceID get_space_id() const { + return space_id; + } + + ::nebula::cpp2::GraphSpaceID& set_space_id( ::nebula::cpp2::GraphSpaceID space_id_) { + space_id = space_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.space_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return space_id; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< ListEdgeIndexesReq >; + friend void swap(ListEdgeIndexesReq& a, ListEdgeIndexesReq& b); +}; + +template +uint32_t ListEdgeIndexesReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class ListEdgeIndexesResp final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = ListEdgeIndexesResp; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + ListEdgeIndexesResp() : + code( ::nebula::cpp2::ErrorCode::SUCCEEDED) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + ListEdgeIndexesResp(apache::thrift::FragileConstructor, ::nebula::cpp2::ErrorCode code__arg, nebula::HostAddr leader__arg, ::std::vector< ::nebula::meta::cpp2::IndexItem> items__arg); + + ListEdgeIndexesResp(ListEdgeIndexesResp&&) = default; + + ListEdgeIndexesResp(const ListEdgeIndexesResp&) = default; + + + ListEdgeIndexesResp& operator=(ListEdgeIndexesResp&&) = default; + + ListEdgeIndexesResp& operator=(const ListEdgeIndexesResp&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::ErrorCode code; + private: + nebula::HostAddr leader; + private: + ::std::vector< ::nebula::meta::cpp2::IndexItem> items; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool code; + bool leader; + bool items; + } __isset = {}; + bool operator==(const ListEdgeIndexesResp& rhs) const; +#ifndef SWIG + friend bool operator!=(const ListEdgeIndexesResp& __x, const ListEdgeIndexesResp& __y) { + return !(__x == __y); + } +#endif + bool operator<(const ListEdgeIndexesResp& rhs) const; +#ifndef SWIG + friend bool operator>(const ListEdgeIndexesResp& __x, const ListEdgeIndexesResp& __y) { + return __y < __x; + } + friend bool operator<=(const ListEdgeIndexesResp& __x, const ListEdgeIndexesResp& __y) { + return !(__y < __x); + } + friend bool operator>=(const ListEdgeIndexesResp& __x, const ListEdgeIndexesResp& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() const& { + return {this->code, __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() const&& { + return {std::move(this->code), __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() & { + return {this->code, __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() && { + return {std::move(this->code), __isset.code}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() const& { + return {this->leader, __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() const&& { + return {std::move(this->leader), __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() & { + return {this->leader, __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() && { + return {std::move(this->leader), __isset.leader}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::field_ref items_ref() const& { + return {this->items, __isset.items}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref items_ref() const&& { + return {std::move(this->items), __isset.items}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref items_ref() & { + return {this->items, __isset.items}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref items_ref() && { + return {std::move(this->items), __isset.items}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::ErrorCode get_code() const { + return code; + } + + ::nebula::cpp2::ErrorCode& set_code( ::nebula::cpp2::ErrorCode code_) { + code = code_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.code = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return code; + } + const nebula::HostAddr& get_leader() const&; + nebula::HostAddr get_leader() &&; + + template + nebula::HostAddr& set_leader(T_ListEdgeIndexesResp_leader_struct_setter&& leader_) { + leader = std::forward(leader_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.leader = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return leader; + } + const ::std::vector< ::nebula::meta::cpp2::IndexItem>& get_items() const&; + ::std::vector< ::nebula::meta::cpp2::IndexItem> get_items() &&; + + template > + ::std::vector< ::nebula::meta::cpp2::IndexItem>& set_items(T_ListEdgeIndexesResp_items_struct_setter&& items_) { + items = std::forward(items_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.items = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return items; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< ListEdgeIndexesResp >; + friend void swap(ListEdgeIndexesResp& a, ListEdgeIndexesResp& b); +}; + +template +uint32_t ListEdgeIndexesResp::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class RebuildIndexReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = RebuildIndexReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + RebuildIndexReq() : + space_id(0) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + RebuildIndexReq(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, ::std::string index_name__arg); + + RebuildIndexReq(RebuildIndexReq&&) = default; + + RebuildIndexReq(const RebuildIndexReq&) = default; + + + RebuildIndexReq& operator=(RebuildIndexReq&&) = default; + + RebuildIndexReq& operator=(const RebuildIndexReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::GraphSpaceID space_id; + private: + ::std::string index_name; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool space_id; + bool index_name; + } __isset = {}; + bool operator==(const RebuildIndexReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const RebuildIndexReq& __x, const RebuildIndexReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const RebuildIndexReq& rhs) const; +#ifndef SWIG + friend bool operator>(const RebuildIndexReq& __x, const RebuildIndexReq& __y) { + return __y < __x; + } + friend bool operator<=(const RebuildIndexReq& __x, const RebuildIndexReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const RebuildIndexReq& __x, const RebuildIndexReq& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const& { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const&& { + return {std::move(this->space_id), __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() & { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() && { + return {std::move(this->space_id), __isset.space_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref index_name_ref() const& { + return {this->index_name, __isset.index_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref index_name_ref() const&& { + return {std::move(this->index_name), __isset.index_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref index_name_ref() & { + return {this->index_name, __isset.index_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref index_name_ref() && { + return {std::move(this->index_name), __isset.index_name}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::GraphSpaceID get_space_id() const { + return space_id; + } + + ::nebula::cpp2::GraphSpaceID& set_space_id( ::nebula::cpp2::GraphSpaceID space_id_) { + space_id = space_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.space_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return space_id; + } + + const ::std::string& get_index_name() const& { + return index_name; + } + + ::std::string get_index_name() && { + return std::move(index_name); + } + + template + ::std::string& set_index_name(T_RebuildIndexReq_index_name_struct_setter&& index_name_) { + index_name = std::forward(index_name_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.index_name = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return index_name; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< RebuildIndexReq >; + friend void swap(RebuildIndexReq& a, RebuildIndexReq& b); +}; + +template +uint32_t RebuildIndexReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class CreateUserReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = CreateUserReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + CreateUserReq() : + if_not_exists(0) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + CreateUserReq(apache::thrift::FragileConstructor, ::std::string account__arg, ::std::string encoded_pwd__arg, bool if_not_exists__arg); + + CreateUserReq(CreateUserReq&&) = default; + + CreateUserReq(const CreateUserReq&) = default; + + + CreateUserReq& operator=(CreateUserReq&&) = default; + + CreateUserReq& operator=(const CreateUserReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::std::string account; + private: + ::std::string encoded_pwd; + private: + bool if_not_exists; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool account; + bool encoded_pwd; + bool if_not_exists; + } __isset = {}; + bool operator==(const CreateUserReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const CreateUserReq& __x, const CreateUserReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const CreateUserReq& rhs) const; +#ifndef SWIG + friend bool operator>(const CreateUserReq& __x, const CreateUserReq& __y) { + return __y < __x; + } + friend bool operator<=(const CreateUserReq& __x, const CreateUserReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const CreateUserReq& __x, const CreateUserReq& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref account_ref() const& { + return {this->account, __isset.account}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref account_ref() const&& { + return {std::move(this->account), __isset.account}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref account_ref() & { + return {this->account, __isset.account}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref account_ref() && { + return {std::move(this->account), __isset.account}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref encoded_pwd_ref() const& { + return {this->encoded_pwd, __isset.encoded_pwd}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref encoded_pwd_ref() const&& { + return {std::move(this->encoded_pwd), __isset.encoded_pwd}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref encoded_pwd_ref() & { + return {this->encoded_pwd, __isset.encoded_pwd}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref encoded_pwd_ref() && { + return {std::move(this->encoded_pwd), __isset.encoded_pwd}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref if_not_exists_ref() const& { + return {this->if_not_exists, __isset.if_not_exists}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref if_not_exists_ref() const&& { + return {std::move(this->if_not_exists), __isset.if_not_exists}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref if_not_exists_ref() & { + return {this->if_not_exists, __isset.if_not_exists}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref if_not_exists_ref() && { + return {std::move(this->if_not_exists), __isset.if_not_exists}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + const ::std::string& get_account() const& { + return account; + } + + ::std::string get_account() && { + return std::move(account); + } + + template + ::std::string& set_account(T_CreateUserReq_account_struct_setter&& account_) { + account = std::forward(account_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.account = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return account; + } + + const ::std::string& get_encoded_pwd() const& { + return encoded_pwd; + } + + ::std::string get_encoded_pwd() && { + return std::move(encoded_pwd); + } + + template + ::std::string& set_encoded_pwd(T_CreateUserReq_encoded_pwd_struct_setter&& encoded_pwd_) { + encoded_pwd = std::forward(encoded_pwd_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.encoded_pwd = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return encoded_pwd; + } + + bool get_if_not_exists() const { + return if_not_exists; + } + + bool& set_if_not_exists(bool if_not_exists_) { + if_not_exists = if_not_exists_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.if_not_exists = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return if_not_exists; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< CreateUserReq >; + friend void swap(CreateUserReq& a, CreateUserReq& b); +}; + +template +uint32_t CreateUserReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class DropUserReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = DropUserReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + DropUserReq() : + if_exists(0) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + DropUserReq(apache::thrift::FragileConstructor, ::std::string account__arg, bool if_exists__arg); + + DropUserReq(DropUserReq&&) = default; + + DropUserReq(const DropUserReq&) = default; + + + DropUserReq& operator=(DropUserReq&&) = default; + + DropUserReq& operator=(const DropUserReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::std::string account; + private: + bool if_exists; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool account; + bool if_exists; + } __isset = {}; + bool operator==(const DropUserReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const DropUserReq& __x, const DropUserReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const DropUserReq& rhs) const; +#ifndef SWIG + friend bool operator>(const DropUserReq& __x, const DropUserReq& __y) { + return __y < __x; + } + friend bool operator<=(const DropUserReq& __x, const DropUserReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const DropUserReq& __x, const DropUserReq& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref account_ref() const& { + return {this->account, __isset.account}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref account_ref() const&& { + return {std::move(this->account), __isset.account}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref account_ref() & { + return {this->account, __isset.account}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref account_ref() && { + return {std::move(this->account), __isset.account}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref if_exists_ref() const& { + return {this->if_exists, __isset.if_exists}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref if_exists_ref() const&& { + return {std::move(this->if_exists), __isset.if_exists}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref if_exists_ref() & { + return {this->if_exists, __isset.if_exists}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref if_exists_ref() && { + return {std::move(this->if_exists), __isset.if_exists}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + const ::std::string& get_account() const& { + return account; + } + + ::std::string get_account() && { + return std::move(account); + } + + template + ::std::string& set_account(T_DropUserReq_account_struct_setter&& account_) { + account = std::forward(account_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.account = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return account; + } + + bool get_if_exists() const { + return if_exists; + } + + bool& set_if_exists(bool if_exists_) { + if_exists = if_exists_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.if_exists = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return if_exists; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< DropUserReq >; + friend void swap(DropUserReq& a, DropUserReq& b); +}; + +template +uint32_t DropUserReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class AlterUserReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = AlterUserReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + AlterUserReq() {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + AlterUserReq(apache::thrift::FragileConstructor, ::std::string account__arg, ::std::string encoded_pwd__arg); + + AlterUserReq(AlterUserReq&&) = default; + + AlterUserReq(const AlterUserReq&) = default; + + + AlterUserReq& operator=(AlterUserReq&&) = default; + + AlterUserReq& operator=(const AlterUserReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::std::string account; + private: + ::std::string encoded_pwd; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool account; + bool encoded_pwd; + } __isset = {}; + bool operator==(const AlterUserReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const AlterUserReq& __x, const AlterUserReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const AlterUserReq& rhs) const; +#ifndef SWIG + friend bool operator>(const AlterUserReq& __x, const AlterUserReq& __y) { + return __y < __x; + } + friend bool operator<=(const AlterUserReq& __x, const AlterUserReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const AlterUserReq& __x, const AlterUserReq& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref account_ref() const& { + return {this->account, __isset.account}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref account_ref() const&& { + return {std::move(this->account), __isset.account}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref account_ref() & { + return {this->account, __isset.account}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref account_ref() && { + return {std::move(this->account), __isset.account}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref encoded_pwd_ref() const& { + return {this->encoded_pwd, __isset.encoded_pwd}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref encoded_pwd_ref() const&& { + return {std::move(this->encoded_pwd), __isset.encoded_pwd}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref encoded_pwd_ref() & { + return {this->encoded_pwd, __isset.encoded_pwd}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref encoded_pwd_ref() && { + return {std::move(this->encoded_pwd), __isset.encoded_pwd}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + const ::std::string& get_account() const& { + return account; + } + + ::std::string get_account() && { + return std::move(account); + } + + template + ::std::string& set_account(T_AlterUserReq_account_struct_setter&& account_) { + account = std::forward(account_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.account = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return account; + } + + const ::std::string& get_encoded_pwd() const& { + return encoded_pwd; + } + + ::std::string get_encoded_pwd() && { + return std::move(encoded_pwd); + } + + template + ::std::string& set_encoded_pwd(T_AlterUserReq_encoded_pwd_struct_setter&& encoded_pwd_) { + encoded_pwd = std::forward(encoded_pwd_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.encoded_pwd = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return encoded_pwd; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< AlterUserReq >; + friend void swap(AlterUserReq& a, AlterUserReq& b); +}; + +template +uint32_t AlterUserReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class GrantRoleReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = GrantRoleReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + GrantRoleReq() {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + GrantRoleReq(apache::thrift::FragileConstructor, ::nebula::meta::cpp2::RoleItem role_item__arg); + + GrantRoleReq(GrantRoleReq&&) = default; + + GrantRoleReq(const GrantRoleReq&) = default; + + + GrantRoleReq& operator=(GrantRoleReq&&) = default; + + GrantRoleReq& operator=(const GrantRoleReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::meta::cpp2::RoleItem role_item; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool role_item; + } __isset = {}; + bool operator==(const GrantRoleReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const GrantRoleReq& __x, const GrantRoleReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const GrantRoleReq& rhs) const; +#ifndef SWIG + friend bool operator>(const GrantRoleReq& __x, const GrantRoleReq& __y) { + return __y < __x; + } + friend bool operator<=(const GrantRoleReq& __x, const GrantRoleReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const GrantRoleReq& __x, const GrantRoleReq& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref role_item_ref() const& { + return {this->role_item, __isset.role_item}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref role_item_ref() const&& { + return {std::move(this->role_item), __isset.role_item}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref role_item_ref() & { + return {this->role_item, __isset.role_item}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref role_item_ref() && { + return {std::move(this->role_item), __isset.role_item}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + const ::nebula::meta::cpp2::RoleItem& get_role_item() const&; + ::nebula::meta::cpp2::RoleItem get_role_item() &&; + + template + ::nebula::meta::cpp2::RoleItem& set_role_item(T_GrantRoleReq_role_item_struct_setter&& role_item_) { + role_item = std::forward(role_item_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.role_item = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return role_item; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< GrantRoleReq >; + friend void swap(GrantRoleReq& a, GrantRoleReq& b); +}; + +template +uint32_t GrantRoleReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class RevokeRoleReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = RevokeRoleReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + RevokeRoleReq() {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + RevokeRoleReq(apache::thrift::FragileConstructor, ::nebula::meta::cpp2::RoleItem role_item__arg); + + RevokeRoleReq(RevokeRoleReq&&) = default; + + RevokeRoleReq(const RevokeRoleReq&) = default; + + + RevokeRoleReq& operator=(RevokeRoleReq&&) = default; + + RevokeRoleReq& operator=(const RevokeRoleReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::meta::cpp2::RoleItem role_item; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool role_item; + } __isset = {}; + bool operator==(const RevokeRoleReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const RevokeRoleReq& __x, const RevokeRoleReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const RevokeRoleReq& rhs) const; +#ifndef SWIG + friend bool operator>(const RevokeRoleReq& __x, const RevokeRoleReq& __y) { + return __y < __x; + } + friend bool operator<=(const RevokeRoleReq& __x, const RevokeRoleReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const RevokeRoleReq& __x, const RevokeRoleReq& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref role_item_ref() const& { + return {this->role_item, __isset.role_item}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref role_item_ref() const&& { + return {std::move(this->role_item), __isset.role_item}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref role_item_ref() & { + return {this->role_item, __isset.role_item}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref role_item_ref() && { + return {std::move(this->role_item), __isset.role_item}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + const ::nebula::meta::cpp2::RoleItem& get_role_item() const&; + ::nebula::meta::cpp2::RoleItem get_role_item() &&; + + template + ::nebula::meta::cpp2::RoleItem& set_role_item(T_RevokeRoleReq_role_item_struct_setter&& role_item_) { + role_item = std::forward(role_item_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.role_item = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return role_item; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< RevokeRoleReq >; + friend void swap(RevokeRoleReq& a, RevokeRoleReq& b); +}; + +template +uint32_t RevokeRoleReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class ListUsersReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = ListUsersReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + ListUsersReq() {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + ListUsersReq(apache::thrift::FragileConstructor); + + ListUsersReq(ListUsersReq&&) = default; + + ListUsersReq(const ListUsersReq&) = default; + + + ListUsersReq& operator=(ListUsersReq&&) = default; + + ListUsersReq& operator=(const ListUsersReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + bool operator==(const ListUsersReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const ListUsersReq& __x, const ListUsersReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const ListUsersReq& rhs) const; +#ifndef SWIG + friend bool operator>(const ListUsersReq& __x, const ListUsersReq& __y) { + return __y < __x; + } + friend bool operator<=(const ListUsersReq& __x, const ListUsersReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const ListUsersReq& __x, const ListUsersReq& __y) { + return !(__x < __y); + } +#endif + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< ListUsersReq >; + friend void swap(ListUsersReq& a, ListUsersReq& b); +}; + +template +uint32_t ListUsersReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class ListUsersResp final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = ListUsersResp; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + ListUsersResp() : + code( ::nebula::cpp2::ErrorCode::SUCCEEDED) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + ListUsersResp(apache::thrift::FragileConstructor, ::nebula::cpp2::ErrorCode code__arg, nebula::HostAddr leader__arg, std::unordered_map<::std::string, ::std::string> users__arg); + + ListUsersResp(ListUsersResp&&) = default; + + ListUsersResp(const ListUsersResp&) = default; + + + ListUsersResp& operator=(ListUsersResp&&) = default; + + ListUsersResp& operator=(const ListUsersResp&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::ErrorCode code; + private: + nebula::HostAddr leader; + private: + std::unordered_map<::std::string, ::std::string> users; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool code; + bool leader; + bool users; + } __isset = {}; + bool operator==(const ListUsersResp& rhs) const; +#ifndef SWIG + friend bool operator!=(const ListUsersResp& __x, const ListUsersResp& __y) { + return !(__x == __y); + } +#endif + bool operator<(const ListUsersResp& rhs) const; +#ifndef SWIG + friend bool operator>(const ListUsersResp& __x, const ListUsersResp& __y) { + return __y < __x; + } + friend bool operator<=(const ListUsersResp& __x, const ListUsersResp& __y) { + return !(__y < __x); + } + friend bool operator>=(const ListUsersResp& __x, const ListUsersResp& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() const& { + return {this->code, __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() const&& { + return {std::move(this->code), __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() & { + return {this->code, __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() && { + return {std::move(this->code), __isset.code}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() const& { + return {this->leader, __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() const&& { + return {std::move(this->leader), __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() & { + return {this->leader, __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() && { + return {std::move(this->leader), __isset.leader}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::field_ref users_ref() const& { + return {this->users, __isset.users}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref users_ref() const&& { + return {std::move(this->users), __isset.users}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref users_ref() & { + return {this->users, __isset.users}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref users_ref() && { + return {std::move(this->users), __isset.users}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::ErrorCode get_code() const { + return code; + } + + ::nebula::cpp2::ErrorCode& set_code( ::nebula::cpp2::ErrorCode code_) { + code = code_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.code = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return code; + } + const nebula::HostAddr& get_leader() const&; + nebula::HostAddr get_leader() &&; + + template + nebula::HostAddr& set_leader(T_ListUsersResp_leader_struct_setter&& leader_) { + leader = std::forward(leader_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.leader = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return leader; + } + const std::unordered_map<::std::string, ::std::string>& get_users() const&; + std::unordered_map<::std::string, ::std::string> get_users() &&; + + template > + std::unordered_map<::std::string, ::std::string>& set_users(T_ListUsersResp_users_struct_setter&& users_) { + users = std::forward(users_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.users = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return users; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< ListUsersResp >; + friend void swap(ListUsersResp& a, ListUsersResp& b); +}; + +template +uint32_t ListUsersResp::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class ListRolesReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = ListRolesReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + ListRolesReq() : + space_id(0) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + ListRolesReq(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg); + + ListRolesReq(ListRolesReq&&) = default; + + ListRolesReq(const ListRolesReq&) = default; + + + ListRolesReq& operator=(ListRolesReq&&) = default; + + ListRolesReq& operator=(const ListRolesReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::GraphSpaceID space_id; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool space_id; + } __isset = {}; + bool operator==(const ListRolesReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const ListRolesReq& __x, const ListRolesReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const ListRolesReq& rhs) const; +#ifndef SWIG + friend bool operator>(const ListRolesReq& __x, const ListRolesReq& __y) { + return __y < __x; + } + friend bool operator<=(const ListRolesReq& __x, const ListRolesReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const ListRolesReq& __x, const ListRolesReq& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const& { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const&& { + return {std::move(this->space_id), __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() & { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() && { + return {std::move(this->space_id), __isset.space_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::GraphSpaceID get_space_id() const { + return space_id; + } + + ::nebula::cpp2::GraphSpaceID& set_space_id( ::nebula::cpp2::GraphSpaceID space_id_) { + space_id = space_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.space_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return space_id; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< ListRolesReq >; + friend void swap(ListRolesReq& a, ListRolesReq& b); +}; + +template +uint32_t ListRolesReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class ListRolesResp final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = ListRolesResp; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + ListRolesResp() : + code( ::nebula::cpp2::ErrorCode::SUCCEEDED) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + ListRolesResp(apache::thrift::FragileConstructor, ::nebula::cpp2::ErrorCode code__arg, nebula::HostAddr leader__arg, ::std::vector< ::nebula::meta::cpp2::RoleItem> roles__arg); + + ListRolesResp(ListRolesResp&&) = default; + + ListRolesResp(const ListRolesResp&) = default; + + + ListRolesResp& operator=(ListRolesResp&&) = default; + + ListRolesResp& operator=(const ListRolesResp&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::ErrorCode code; + private: + nebula::HostAddr leader; + private: + ::std::vector< ::nebula::meta::cpp2::RoleItem> roles; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool code; + bool leader; + bool roles; + } __isset = {}; + bool operator==(const ListRolesResp& rhs) const; +#ifndef SWIG + friend bool operator!=(const ListRolesResp& __x, const ListRolesResp& __y) { + return !(__x == __y); + } +#endif + bool operator<(const ListRolesResp& rhs) const; +#ifndef SWIG + friend bool operator>(const ListRolesResp& __x, const ListRolesResp& __y) { + return __y < __x; + } + friend bool operator<=(const ListRolesResp& __x, const ListRolesResp& __y) { + return !(__y < __x); + } + friend bool operator>=(const ListRolesResp& __x, const ListRolesResp& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() const& { + return {this->code, __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() const&& { + return {std::move(this->code), __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() & { + return {this->code, __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() && { + return {std::move(this->code), __isset.code}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() const& { + return {this->leader, __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() const&& { + return {std::move(this->leader), __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() & { + return {this->leader, __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() && { + return {std::move(this->leader), __isset.leader}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::field_ref roles_ref() const& { + return {this->roles, __isset.roles}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref roles_ref() const&& { + return {std::move(this->roles), __isset.roles}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref roles_ref() & { + return {this->roles, __isset.roles}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref roles_ref() && { + return {std::move(this->roles), __isset.roles}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::ErrorCode get_code() const { + return code; + } + + ::nebula::cpp2::ErrorCode& set_code( ::nebula::cpp2::ErrorCode code_) { + code = code_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.code = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return code; + } + const nebula::HostAddr& get_leader() const&; + nebula::HostAddr get_leader() &&; + + template + nebula::HostAddr& set_leader(T_ListRolesResp_leader_struct_setter&& leader_) { + leader = std::forward(leader_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.leader = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return leader; + } + const ::std::vector< ::nebula::meta::cpp2::RoleItem>& get_roles() const&; + ::std::vector< ::nebula::meta::cpp2::RoleItem> get_roles() &&; + + template > + ::std::vector< ::nebula::meta::cpp2::RoleItem>& set_roles(T_ListRolesResp_roles_struct_setter&& roles_) { + roles = std::forward(roles_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.roles = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return roles; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< ListRolesResp >; + friend void swap(ListRolesResp& a, ListRolesResp& b); +}; + +template +uint32_t ListRolesResp::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class GetUserRolesReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = GetUserRolesReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + GetUserRolesReq() {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + GetUserRolesReq(apache::thrift::FragileConstructor, ::std::string account__arg); + + GetUserRolesReq(GetUserRolesReq&&) = default; + + GetUserRolesReq(const GetUserRolesReq&) = default; + + + GetUserRolesReq& operator=(GetUserRolesReq&&) = default; + + GetUserRolesReq& operator=(const GetUserRolesReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::std::string account; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool account; + } __isset = {}; + bool operator==(const GetUserRolesReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const GetUserRolesReq& __x, const GetUserRolesReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const GetUserRolesReq& rhs) const; +#ifndef SWIG + friend bool operator>(const GetUserRolesReq& __x, const GetUserRolesReq& __y) { + return __y < __x; + } + friend bool operator<=(const GetUserRolesReq& __x, const GetUserRolesReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const GetUserRolesReq& __x, const GetUserRolesReq& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref account_ref() const& { + return {this->account, __isset.account}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref account_ref() const&& { + return {std::move(this->account), __isset.account}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref account_ref() & { + return {this->account, __isset.account}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref account_ref() && { + return {std::move(this->account), __isset.account}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + const ::std::string& get_account() const& { + return account; + } + + ::std::string get_account() && { + return std::move(account); + } + + template + ::std::string& set_account(T_GetUserRolesReq_account_struct_setter&& account_) { + account = std::forward(account_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.account = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return account; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< GetUserRolesReq >; + friend void swap(GetUserRolesReq& a, GetUserRolesReq& b); +}; + +template +uint32_t GetUserRolesReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class ChangePasswordReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = ChangePasswordReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + ChangePasswordReq() {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + ChangePasswordReq(apache::thrift::FragileConstructor, ::std::string account__arg, ::std::string new_encoded_pwd__arg, ::std::string old_encoded_pwd__arg); + + ChangePasswordReq(ChangePasswordReq&&) = default; + + ChangePasswordReq(const ChangePasswordReq&) = default; + + + ChangePasswordReq& operator=(ChangePasswordReq&&) = default; + + ChangePasswordReq& operator=(const ChangePasswordReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::std::string account; + private: + ::std::string new_encoded_pwd; + private: + ::std::string old_encoded_pwd; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool account; + bool new_encoded_pwd; + bool old_encoded_pwd; + } __isset = {}; + bool operator==(const ChangePasswordReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const ChangePasswordReq& __x, const ChangePasswordReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const ChangePasswordReq& rhs) const; +#ifndef SWIG + friend bool operator>(const ChangePasswordReq& __x, const ChangePasswordReq& __y) { + return __y < __x; + } + friend bool operator<=(const ChangePasswordReq& __x, const ChangePasswordReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const ChangePasswordReq& __x, const ChangePasswordReq& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref account_ref() const& { + return {this->account, __isset.account}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref account_ref() const&& { + return {std::move(this->account), __isset.account}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref account_ref() & { + return {this->account, __isset.account}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref account_ref() && { + return {std::move(this->account), __isset.account}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref new_encoded_pwd_ref() const& { + return {this->new_encoded_pwd, __isset.new_encoded_pwd}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref new_encoded_pwd_ref() const&& { + return {std::move(this->new_encoded_pwd), __isset.new_encoded_pwd}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref new_encoded_pwd_ref() & { + return {this->new_encoded_pwd, __isset.new_encoded_pwd}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref new_encoded_pwd_ref() && { + return {std::move(this->new_encoded_pwd), __isset.new_encoded_pwd}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref old_encoded_pwd_ref() const& { + return {this->old_encoded_pwd, __isset.old_encoded_pwd}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref old_encoded_pwd_ref() const&& { + return {std::move(this->old_encoded_pwd), __isset.old_encoded_pwd}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref old_encoded_pwd_ref() & { + return {this->old_encoded_pwd, __isset.old_encoded_pwd}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref old_encoded_pwd_ref() && { + return {std::move(this->old_encoded_pwd), __isset.old_encoded_pwd}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + const ::std::string& get_account() const& { + return account; + } + + ::std::string get_account() && { + return std::move(account); + } + + template + ::std::string& set_account(T_ChangePasswordReq_account_struct_setter&& account_) { + account = std::forward(account_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.account = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return account; + } + + const ::std::string& get_new_encoded_pwd() const& { + return new_encoded_pwd; + } + + ::std::string get_new_encoded_pwd() && { + return std::move(new_encoded_pwd); + } + + template + ::std::string& set_new_encoded_pwd(T_ChangePasswordReq_new_encoded_pwd_struct_setter&& new_encoded_pwd_) { + new_encoded_pwd = std::forward(new_encoded_pwd_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.new_encoded_pwd = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return new_encoded_pwd; + } + + const ::std::string& get_old_encoded_pwd() const& { + return old_encoded_pwd; + } + + ::std::string get_old_encoded_pwd() && { + return std::move(old_encoded_pwd); + } + + template + ::std::string& set_old_encoded_pwd(T_ChangePasswordReq_old_encoded_pwd_struct_setter&& old_encoded_pwd_) { + old_encoded_pwd = std::forward(old_encoded_pwd_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.old_encoded_pwd = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return old_encoded_pwd; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< ChangePasswordReq >; + friend void swap(ChangePasswordReq& a, ChangePasswordReq& b); +}; + +template +uint32_t ChangePasswordReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class BalanceReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = BalanceReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + + BalanceReq(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + BalanceReq(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, int64_t id__arg, ::std::vector host_del__arg, bool stop__arg, bool reset__arg); + + BalanceReq(BalanceReq&&) = default; + + BalanceReq(const BalanceReq&) = default; + + + BalanceReq& operator=(BalanceReq&&) = default; + + BalanceReq& operator=(const BalanceReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + + ~BalanceReq(); + + private: + ::nebula::cpp2::GraphSpaceID space_id; + private: + int64_t id; + private: + ::std::vector host_del; + private: + bool stop; + private: + bool reset; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool space_id; + bool id; + bool host_del; + bool stop; + bool reset; + } __isset = {}; + bool operator==(const BalanceReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const BalanceReq& __x, const BalanceReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const BalanceReq& rhs) const; +#ifndef SWIG + friend bool operator>(const BalanceReq& __x, const BalanceReq& __y) { + return __y < __x; + } + friend bool operator<=(const BalanceReq& __x, const BalanceReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const BalanceReq& __x, const BalanceReq& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::optional_field_ref space_id_ref() const& { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref space_id_ref() const&& { + return {std::move(this->space_id), __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref space_id_ref() & { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref space_id_ref() && { + return {std::move(this->space_id), __isset.space_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::optional_field_ref id_ref() const& { + return {this->id, __isset.id}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref id_ref() const&& { + return {std::move(this->id), __isset.id}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref id_ref() & { + return {this->id, __isset.id}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref id_ref() && { + return {std::move(this->id), __isset.id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::optional_field_ref host_del_ref() const& { + return {this->host_del, __isset.host_del}; + } + + template > + FOLLY_ERASE ::apache::thrift::optional_field_ref host_del_ref() const&& { + return {std::move(this->host_del), __isset.host_del}; + } + + template > + FOLLY_ERASE ::apache::thrift::optional_field_ref host_del_ref() & { + return {this->host_del, __isset.host_del}; + } + + template > + FOLLY_ERASE ::apache::thrift::optional_field_ref host_del_ref() && { + return {std::move(this->host_del), __isset.host_del}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::optional_field_ref stop_ref() const& { + return {this->stop, __isset.stop}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref stop_ref() const&& { + return {std::move(this->stop), __isset.stop}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref stop_ref() & { + return {this->stop, __isset.stop}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref stop_ref() && { + return {std::move(this->stop), __isset.stop}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::optional_field_ref reset_ref() const& { + return {this->reset, __isset.reset}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref reset_ref() const&& { + return {std::move(this->reset), __isset.reset}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref reset_ref() & { + return {this->reset, __isset.reset}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref reset_ref() && { + return {std::move(this->reset), __isset.reset}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + const ::nebula::cpp2::GraphSpaceID* get_space_id() const& { + return space_id_ref() ? std::addressof(space_id) : nullptr; + } + + ::nebula::cpp2::GraphSpaceID* get_space_id() & { + return space_id_ref() ? std::addressof(space_id) : nullptr; + } + ::nebula::cpp2::GraphSpaceID* get_space_id() && = delete; + + ::nebula::cpp2::GraphSpaceID& set_space_id( ::nebula::cpp2::GraphSpaceID space_id_) { + space_id = space_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.space_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return space_id; + } + + const int64_t* get_id() const& { + return id_ref() ? std::addressof(id) : nullptr; + } + + int64_t* get_id() & { + return id_ref() ? std::addressof(id) : nullptr; + } + int64_t* get_id() && = delete; + + int64_t& set_id(int64_t id_) { + id = id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return id; + } + const ::std::vector* get_host_del() const&; + ::std::vector* get_host_del() &; + ::std::vector* get_host_del() && = delete; + + template > + ::std::vector& set_host_del(T_BalanceReq_host_del_struct_setter&& host_del_) { + host_del = std::forward(host_del_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.host_del = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return host_del; + } + + const bool* get_stop() const& { + return stop_ref() ? std::addressof(stop) : nullptr; + } + + bool* get_stop() & { + return stop_ref() ? std::addressof(stop) : nullptr; + } + bool* get_stop() && = delete; + + bool& set_stop(bool stop_) { + stop = stop_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.stop = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return stop; + } + + const bool* get_reset() const& { + return reset_ref() ? std::addressof(reset) : nullptr; + } + + bool* get_reset() & { + return reset_ref() ? std::addressof(reset) : nullptr; + } + bool* get_reset() && = delete; + + bool& set_reset(bool reset_) { + reset = reset_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.reset = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return reset; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< BalanceReq >; + friend void swap(BalanceReq& a, BalanceReq& b); +}; + +template +uint32_t BalanceReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class BalanceTask final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = BalanceTask; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + BalanceTask() : + result( ::nebula::meta::cpp2::TaskResult::SUCCEEDED) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + BalanceTask(apache::thrift::FragileConstructor, ::std::string id__arg, ::nebula::meta::cpp2::TaskResult result__arg); + + BalanceTask(BalanceTask&&) = default; + + BalanceTask(const BalanceTask&) = default; + + + BalanceTask& operator=(BalanceTask&&) = default; + + BalanceTask& operator=(const BalanceTask&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::std::string id; + private: + ::nebula::meta::cpp2::TaskResult result; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool id; + bool result; + } __isset = {}; + bool operator==(const BalanceTask& rhs) const; +#ifndef SWIG + friend bool operator!=(const BalanceTask& __x, const BalanceTask& __y) { + return !(__x == __y); + } +#endif + bool operator<(const BalanceTask& rhs) const; +#ifndef SWIG + friend bool operator>(const BalanceTask& __x, const BalanceTask& __y) { + return __y < __x; + } + friend bool operator<=(const BalanceTask& __x, const BalanceTask& __y) { + return !(__y < __x); + } + friend bool operator>=(const BalanceTask& __x, const BalanceTask& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref id_ref() const& { + return {this->id, __isset.id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref id_ref() const&& { + return {std::move(this->id), __isset.id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref id_ref() & { + return {this->id, __isset.id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref id_ref() && { + return {std::move(this->id), __isset.id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref result_ref() const& { + return {this->result, __isset.result}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref result_ref() const&& { + return {std::move(this->result), __isset.result}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref result_ref() & { + return {this->result, __isset.result}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref result_ref() && { + return {std::move(this->result), __isset.result}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + const ::std::string& get_id() const& { + return id; + } + + ::std::string get_id() && { + return std::move(id); + } + + template + ::std::string& set_id(T_BalanceTask_id_struct_setter&& id_) { + id = std::forward(id_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return id; + } + + ::nebula::meta::cpp2::TaskResult get_result() const { + return result; + } + + ::nebula::meta::cpp2::TaskResult& set_result( ::nebula::meta::cpp2::TaskResult result_) { + result = result_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.result = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return result; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< BalanceTask >; + friend void swap(BalanceTask& a, BalanceTask& b); +}; + +template +uint32_t BalanceTask::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class BalanceResp final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = BalanceResp; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + BalanceResp() : + code( ::nebula::cpp2::ErrorCode::SUCCEEDED), + id(0) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + BalanceResp(apache::thrift::FragileConstructor, ::nebula::cpp2::ErrorCode code__arg, int64_t id__arg, nebula::HostAddr leader__arg, ::std::vector< ::nebula::meta::cpp2::BalanceTask> tasks__arg); + + BalanceResp(BalanceResp&&) = default; + + BalanceResp(const BalanceResp&) = default; + + + BalanceResp& operator=(BalanceResp&&) = default; + + BalanceResp& operator=(const BalanceResp&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::ErrorCode code; + private: + int64_t id; + private: + nebula::HostAddr leader; + private: + ::std::vector< ::nebula::meta::cpp2::BalanceTask> tasks; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool code; + bool id; + bool leader; + bool tasks; + } __isset = {}; + bool operator==(const BalanceResp& rhs) const; +#ifndef SWIG + friend bool operator!=(const BalanceResp& __x, const BalanceResp& __y) { + return !(__x == __y); + } +#endif + bool operator<(const BalanceResp& rhs) const; +#ifndef SWIG + friend bool operator>(const BalanceResp& __x, const BalanceResp& __y) { + return __y < __x; + } + friend bool operator<=(const BalanceResp& __x, const BalanceResp& __y) { + return !(__y < __x); + } + friend bool operator>=(const BalanceResp& __x, const BalanceResp& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() const& { + return {this->code, __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() const&& { + return {std::move(this->code), __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() & { + return {this->code, __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() && { + return {std::move(this->code), __isset.code}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref id_ref() const& { + return {this->id, __isset.id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref id_ref() const&& { + return {std::move(this->id), __isset.id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref id_ref() & { + return {this->id, __isset.id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref id_ref() && { + return {std::move(this->id), __isset.id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() const& { + return {this->leader, __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() const&& { + return {std::move(this->leader), __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() & { + return {this->leader, __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() && { + return {std::move(this->leader), __isset.leader}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::field_ref tasks_ref() const& { + return {this->tasks, __isset.tasks}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref tasks_ref() const&& { + return {std::move(this->tasks), __isset.tasks}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref tasks_ref() & { + return {this->tasks, __isset.tasks}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref tasks_ref() && { + return {std::move(this->tasks), __isset.tasks}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::ErrorCode get_code() const { + return code; + } + + ::nebula::cpp2::ErrorCode& set_code( ::nebula::cpp2::ErrorCode code_) { + code = code_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.code = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return code; + } + + int64_t get_id() const { + return id; + } + + int64_t& set_id(int64_t id_) { + id = id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return id; + } + const nebula::HostAddr& get_leader() const&; + nebula::HostAddr get_leader() &&; + + template + nebula::HostAddr& set_leader(T_BalanceResp_leader_struct_setter&& leader_) { + leader = std::forward(leader_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.leader = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return leader; + } + const ::std::vector< ::nebula::meta::cpp2::BalanceTask>& get_tasks() const&; + ::std::vector< ::nebula::meta::cpp2::BalanceTask> get_tasks() &&; + + template > + ::std::vector< ::nebula::meta::cpp2::BalanceTask>& set_tasks(T_BalanceResp_tasks_struct_setter&& tasks_) { + tasks = std::forward(tasks_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.tasks = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return tasks; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< BalanceResp >; + friend void swap(BalanceResp& a, BalanceResp& b); +}; + +template +uint32_t BalanceResp::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class LeaderBalanceReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = LeaderBalanceReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + LeaderBalanceReq() {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + LeaderBalanceReq(apache::thrift::FragileConstructor); + + LeaderBalanceReq(LeaderBalanceReq&&) = default; + + LeaderBalanceReq(const LeaderBalanceReq&) = default; + + + LeaderBalanceReq& operator=(LeaderBalanceReq&&) = default; + + LeaderBalanceReq& operator=(const LeaderBalanceReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + bool operator==(const LeaderBalanceReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const LeaderBalanceReq& __x, const LeaderBalanceReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const LeaderBalanceReq& rhs) const; +#ifndef SWIG + friend bool operator>(const LeaderBalanceReq& __x, const LeaderBalanceReq& __y) { + return __y < __x; + } + friend bool operator<=(const LeaderBalanceReq& __x, const LeaderBalanceReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const LeaderBalanceReq& __x, const LeaderBalanceReq& __y) { + return !(__x < __y); + } +#endif + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< LeaderBalanceReq >; + friend void swap(LeaderBalanceReq& a, LeaderBalanceReq& b); +}; + +template +uint32_t LeaderBalanceReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class ConfigItem final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = ConfigItem; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + ConfigItem() : + module( ::nebula::meta::cpp2::ConfigModule::UNKNOWN), + mode( ::nebula::meta::cpp2::ConfigMode::IMMUTABLE) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + ConfigItem(apache::thrift::FragileConstructor, ::nebula::meta::cpp2::ConfigModule module__arg, ::std::string name__arg, ::nebula::meta::cpp2::ConfigMode mode__arg, nebula::Value value__arg); + + ConfigItem(ConfigItem&&) = default; + + ConfigItem(const ConfigItem&) = default; + + + ConfigItem& operator=(ConfigItem&&) = default; + + ConfigItem& operator=(const ConfigItem&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::meta::cpp2::ConfigModule module; + private: + ::std::string name; + private: + ::nebula::meta::cpp2::ConfigMode mode; + private: + nebula::Value value; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool module; + bool name; + bool mode; + bool value; + } __isset = {}; + bool operator==(const ConfigItem& rhs) const; +#ifndef SWIG + friend bool operator!=(const ConfigItem& __x, const ConfigItem& __y) { + return !(__x == __y); + } +#endif + bool operator<(const ConfigItem& rhs) const; +#ifndef SWIG + friend bool operator>(const ConfigItem& __x, const ConfigItem& __y) { + return __y < __x; + } + friend bool operator<=(const ConfigItem& __x, const ConfigItem& __y) { + return !(__y < __x); + } + friend bool operator>=(const ConfigItem& __x, const ConfigItem& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref module_ref() const& { + return {this->module, __isset.module}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref module_ref() const&& { + return {std::move(this->module), __isset.module}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref module_ref() & { + return {this->module, __isset.module}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref module_ref() && { + return {std::move(this->module), __isset.module}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref name_ref() const& { + return {this->name, __isset.name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref name_ref() const&& { + return {std::move(this->name), __isset.name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref name_ref() & { + return {this->name, __isset.name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref name_ref() && { + return {std::move(this->name), __isset.name}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref mode_ref() const& { + return {this->mode, __isset.mode}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref mode_ref() const&& { + return {std::move(this->mode), __isset.mode}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref mode_ref() & { + return {this->mode, __isset.mode}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref mode_ref() && { + return {std::move(this->mode), __isset.mode}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref value_ref() const& { + return {this->value, __isset.value}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref value_ref() const&& { + return {std::move(this->value), __isset.value}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref value_ref() & { + return {this->value, __isset.value}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref value_ref() && { + return {std::move(this->value), __isset.value}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::meta::cpp2::ConfigModule get_module() const { + return module; + } + + ::nebula::meta::cpp2::ConfigModule& set_module( ::nebula::meta::cpp2::ConfigModule module_) { + module = module_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.module = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return module; + } + + const ::std::string& get_name() const& { + return name; + } + + ::std::string get_name() && { + return std::move(name); + } + + template + ::std::string& set_name(T_ConfigItem_name_struct_setter&& name_) { + name = std::forward(name_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.name = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return name; + } + + ::nebula::meta::cpp2::ConfigMode get_mode() const { + return mode; + } + + ::nebula::meta::cpp2::ConfigMode& set_mode( ::nebula::meta::cpp2::ConfigMode mode_) { + mode = mode_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.mode = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return mode; + } + const nebula::Value& get_value() const&; + nebula::Value get_value() &&; + + template + nebula::Value& set_value(T_ConfigItem_value_struct_setter&& value_) { + value = std::forward(value_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.value = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return value; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< ConfigItem >; + friend void swap(ConfigItem& a, ConfigItem& b); +}; + +template +uint32_t ConfigItem::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class RegConfigReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = RegConfigReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + RegConfigReq() {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + RegConfigReq(apache::thrift::FragileConstructor, ::std::vector< ::nebula::meta::cpp2::ConfigItem> items__arg); + + RegConfigReq(RegConfigReq&&) = default; + + RegConfigReq(const RegConfigReq&) = default; + + + RegConfigReq& operator=(RegConfigReq&&) = default; + + RegConfigReq& operator=(const RegConfigReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::std::vector< ::nebula::meta::cpp2::ConfigItem> items; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool items; + } __isset = {}; + bool operator==(const RegConfigReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const RegConfigReq& __x, const RegConfigReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const RegConfigReq& rhs) const; +#ifndef SWIG + friend bool operator>(const RegConfigReq& __x, const RegConfigReq& __y) { + return __y < __x; + } + friend bool operator<=(const RegConfigReq& __x, const RegConfigReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const RegConfigReq& __x, const RegConfigReq& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::field_ref items_ref() const& { + return {this->items, __isset.items}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref items_ref() const&& { + return {std::move(this->items), __isset.items}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref items_ref() & { + return {this->items, __isset.items}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref items_ref() && { + return {std::move(this->items), __isset.items}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + const ::std::vector< ::nebula::meta::cpp2::ConfigItem>& get_items() const&; + ::std::vector< ::nebula::meta::cpp2::ConfigItem> get_items() &&; + + template > + ::std::vector< ::nebula::meta::cpp2::ConfigItem>& set_items(T_RegConfigReq_items_struct_setter&& items_) { + items = std::forward(items_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.items = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return items; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< RegConfigReq >; + friend void swap(RegConfigReq& a, RegConfigReq& b); +}; + +template +uint32_t RegConfigReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class GetConfigReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = GetConfigReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + GetConfigReq() {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + GetConfigReq(apache::thrift::FragileConstructor, ::nebula::meta::cpp2::ConfigItem item__arg); + + GetConfigReq(GetConfigReq&&) = default; + + GetConfigReq(const GetConfigReq&) = default; + + + GetConfigReq& operator=(GetConfigReq&&) = default; + + GetConfigReq& operator=(const GetConfigReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::meta::cpp2::ConfigItem item; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool item; + } __isset = {}; + bool operator==(const GetConfigReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const GetConfigReq& __x, const GetConfigReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const GetConfigReq& rhs) const; +#ifndef SWIG + friend bool operator>(const GetConfigReq& __x, const GetConfigReq& __y) { + return __y < __x; + } + friend bool operator<=(const GetConfigReq& __x, const GetConfigReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const GetConfigReq& __x, const GetConfigReq& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref item_ref() const& { + return {this->item, __isset.item}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref item_ref() const&& { + return {std::move(this->item), __isset.item}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref item_ref() & { + return {this->item, __isset.item}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref item_ref() && { + return {std::move(this->item), __isset.item}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + const ::nebula::meta::cpp2::ConfigItem& get_item() const&; + ::nebula::meta::cpp2::ConfigItem get_item() &&; + + template + ::nebula::meta::cpp2::ConfigItem& set_item(T_GetConfigReq_item_struct_setter&& item_) { + item = std::forward(item_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.item = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return item; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< GetConfigReq >; + friend void swap(GetConfigReq& a, GetConfigReq& b); +}; + +template +uint32_t GetConfigReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class GetConfigResp final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = GetConfigResp; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + GetConfigResp() : + code( ::nebula::cpp2::ErrorCode::SUCCEEDED) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + GetConfigResp(apache::thrift::FragileConstructor, ::nebula::cpp2::ErrorCode code__arg, nebula::HostAddr leader__arg, ::std::vector< ::nebula::meta::cpp2::ConfigItem> items__arg); + + GetConfigResp(GetConfigResp&&) = default; + + GetConfigResp(const GetConfigResp&) = default; + + + GetConfigResp& operator=(GetConfigResp&&) = default; + + GetConfigResp& operator=(const GetConfigResp&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::ErrorCode code; + private: + nebula::HostAddr leader; + private: + ::std::vector< ::nebula::meta::cpp2::ConfigItem> items; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool code; + bool leader; + bool items; + } __isset = {}; + bool operator==(const GetConfigResp& rhs) const; +#ifndef SWIG + friend bool operator!=(const GetConfigResp& __x, const GetConfigResp& __y) { + return !(__x == __y); + } +#endif + bool operator<(const GetConfigResp& rhs) const; +#ifndef SWIG + friend bool operator>(const GetConfigResp& __x, const GetConfigResp& __y) { + return __y < __x; + } + friend bool operator<=(const GetConfigResp& __x, const GetConfigResp& __y) { + return !(__y < __x); + } + friend bool operator>=(const GetConfigResp& __x, const GetConfigResp& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() const& { + return {this->code, __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() const&& { + return {std::move(this->code), __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() & { + return {this->code, __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() && { + return {std::move(this->code), __isset.code}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() const& { + return {this->leader, __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() const&& { + return {std::move(this->leader), __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() & { + return {this->leader, __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() && { + return {std::move(this->leader), __isset.leader}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::field_ref items_ref() const& { + return {this->items, __isset.items}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref items_ref() const&& { + return {std::move(this->items), __isset.items}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref items_ref() & { + return {this->items, __isset.items}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref items_ref() && { + return {std::move(this->items), __isset.items}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::ErrorCode get_code() const { + return code; + } + + ::nebula::cpp2::ErrorCode& set_code( ::nebula::cpp2::ErrorCode code_) { + code = code_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.code = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return code; + } + const nebula::HostAddr& get_leader() const&; + nebula::HostAddr get_leader() &&; + + template + nebula::HostAddr& set_leader(T_GetConfigResp_leader_struct_setter&& leader_) { + leader = std::forward(leader_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.leader = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return leader; + } + const ::std::vector< ::nebula::meta::cpp2::ConfigItem>& get_items() const&; + ::std::vector< ::nebula::meta::cpp2::ConfigItem> get_items() &&; + + template > + ::std::vector< ::nebula::meta::cpp2::ConfigItem>& set_items(T_GetConfigResp_items_struct_setter&& items_) { + items = std::forward(items_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.items = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return items; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< GetConfigResp >; + friend void swap(GetConfigResp& a, GetConfigResp& b); +}; + +template +uint32_t GetConfigResp::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class SetConfigReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = SetConfigReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + SetConfigReq() {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + SetConfigReq(apache::thrift::FragileConstructor, ::nebula::meta::cpp2::ConfigItem item__arg); + + SetConfigReq(SetConfigReq&&) = default; + + SetConfigReq(const SetConfigReq&) = default; + + + SetConfigReq& operator=(SetConfigReq&&) = default; + + SetConfigReq& operator=(const SetConfigReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::meta::cpp2::ConfigItem item; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool item; + } __isset = {}; + bool operator==(const SetConfigReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const SetConfigReq& __x, const SetConfigReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const SetConfigReq& rhs) const; +#ifndef SWIG + friend bool operator>(const SetConfigReq& __x, const SetConfigReq& __y) { + return __y < __x; + } + friend bool operator<=(const SetConfigReq& __x, const SetConfigReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const SetConfigReq& __x, const SetConfigReq& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref item_ref() const& { + return {this->item, __isset.item}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref item_ref() const&& { + return {std::move(this->item), __isset.item}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref item_ref() & { + return {this->item, __isset.item}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref item_ref() && { + return {std::move(this->item), __isset.item}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + const ::nebula::meta::cpp2::ConfigItem& get_item() const&; + ::nebula::meta::cpp2::ConfigItem get_item() &&; + + template + ::nebula::meta::cpp2::ConfigItem& set_item(T_SetConfigReq_item_struct_setter&& item_) { + item = std::forward(item_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.item = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return item; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< SetConfigReq >; + friend void swap(SetConfigReq& a, SetConfigReq& b); +}; + +template +uint32_t SetConfigReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class ListConfigsReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = ListConfigsReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + ListConfigsReq() : + module( ::nebula::meta::cpp2::ConfigModule::UNKNOWN) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + ListConfigsReq(apache::thrift::FragileConstructor, ::std::string space__arg, ::nebula::meta::cpp2::ConfigModule module__arg); + + ListConfigsReq(ListConfigsReq&&) = default; + + ListConfigsReq(const ListConfigsReq&) = default; + + + ListConfigsReq& operator=(ListConfigsReq&&) = default; + + ListConfigsReq& operator=(const ListConfigsReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::std::string space; + private: + ::nebula::meta::cpp2::ConfigModule module; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool space; + bool module; + } __isset = {}; + bool operator==(const ListConfigsReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const ListConfigsReq& __x, const ListConfigsReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const ListConfigsReq& rhs) const; +#ifndef SWIG + friend bool operator>(const ListConfigsReq& __x, const ListConfigsReq& __y) { + return __y < __x; + } + friend bool operator<=(const ListConfigsReq& __x, const ListConfigsReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const ListConfigsReq& __x, const ListConfigsReq& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref space_ref() const& { + return {this->space, __isset.space}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_ref() const&& { + return {std::move(this->space), __isset.space}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_ref() & { + return {this->space, __isset.space}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_ref() && { + return {std::move(this->space), __isset.space}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref module_ref() const& { + return {this->module, __isset.module}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref module_ref() const&& { + return {std::move(this->module), __isset.module}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref module_ref() & { + return {this->module, __isset.module}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref module_ref() && { + return {std::move(this->module), __isset.module}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + const ::std::string& get_space() const& { + return space; + } + + ::std::string get_space() && { + return std::move(space); + } + + template + ::std::string& set_space(T_ListConfigsReq_space_struct_setter&& space_) { + space = std::forward(space_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.space = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return space; + } + + ::nebula::meta::cpp2::ConfigModule get_module() const { + return module; + } + + ::nebula::meta::cpp2::ConfigModule& set_module( ::nebula::meta::cpp2::ConfigModule module_) { + module = module_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.module = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return module; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< ListConfigsReq >; + friend void swap(ListConfigsReq& a, ListConfigsReq& b); +}; + +template +uint32_t ListConfigsReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class ListConfigsResp final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = ListConfigsResp; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + ListConfigsResp() : + code( ::nebula::cpp2::ErrorCode::SUCCEEDED) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + ListConfigsResp(apache::thrift::FragileConstructor, ::nebula::cpp2::ErrorCode code__arg, nebula::HostAddr leader__arg, ::std::vector< ::nebula::meta::cpp2::ConfigItem> items__arg); + + ListConfigsResp(ListConfigsResp&&) = default; + + ListConfigsResp(const ListConfigsResp&) = default; + + + ListConfigsResp& operator=(ListConfigsResp&&) = default; + + ListConfigsResp& operator=(const ListConfigsResp&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::ErrorCode code; + private: + nebula::HostAddr leader; + private: + ::std::vector< ::nebula::meta::cpp2::ConfigItem> items; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool code; + bool leader; + bool items; + } __isset = {}; + bool operator==(const ListConfigsResp& rhs) const; +#ifndef SWIG + friend bool operator!=(const ListConfigsResp& __x, const ListConfigsResp& __y) { + return !(__x == __y); + } +#endif + bool operator<(const ListConfigsResp& rhs) const; +#ifndef SWIG + friend bool operator>(const ListConfigsResp& __x, const ListConfigsResp& __y) { + return __y < __x; + } + friend bool operator<=(const ListConfigsResp& __x, const ListConfigsResp& __y) { + return !(__y < __x); + } + friend bool operator>=(const ListConfigsResp& __x, const ListConfigsResp& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() const& { + return {this->code, __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() const&& { + return {std::move(this->code), __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() & { + return {this->code, __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() && { + return {std::move(this->code), __isset.code}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() const& { + return {this->leader, __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() const&& { + return {std::move(this->leader), __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() & { + return {this->leader, __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() && { + return {std::move(this->leader), __isset.leader}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::field_ref items_ref() const& { + return {this->items, __isset.items}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref items_ref() const&& { + return {std::move(this->items), __isset.items}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref items_ref() & { + return {this->items, __isset.items}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref items_ref() && { + return {std::move(this->items), __isset.items}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::ErrorCode get_code() const { + return code; + } + + ::nebula::cpp2::ErrorCode& set_code( ::nebula::cpp2::ErrorCode code_) { + code = code_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.code = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return code; + } + const nebula::HostAddr& get_leader() const&; + nebula::HostAddr get_leader() &&; + + template + nebula::HostAddr& set_leader(T_ListConfigsResp_leader_struct_setter&& leader_) { + leader = std::forward(leader_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.leader = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return leader; + } + const ::std::vector< ::nebula::meta::cpp2::ConfigItem>& get_items() const&; + ::std::vector< ::nebula::meta::cpp2::ConfigItem> get_items() &&; + + template > + ::std::vector< ::nebula::meta::cpp2::ConfigItem>& set_items(T_ListConfigsResp_items_struct_setter&& items_) { + items = std::forward(items_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.items = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return items; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< ListConfigsResp >; + friend void swap(ListConfigsResp& a, ListConfigsResp& b); +}; + +template +uint32_t ListConfigsResp::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class CreateSnapshotReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = CreateSnapshotReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + CreateSnapshotReq() {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + CreateSnapshotReq(apache::thrift::FragileConstructor); + + CreateSnapshotReq(CreateSnapshotReq&&) = default; + + CreateSnapshotReq(const CreateSnapshotReq&) = default; + + + CreateSnapshotReq& operator=(CreateSnapshotReq&&) = default; + + CreateSnapshotReq& operator=(const CreateSnapshotReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + bool operator==(const CreateSnapshotReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const CreateSnapshotReq& __x, const CreateSnapshotReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const CreateSnapshotReq& rhs) const; +#ifndef SWIG + friend bool operator>(const CreateSnapshotReq& __x, const CreateSnapshotReq& __y) { + return __y < __x; + } + friend bool operator<=(const CreateSnapshotReq& __x, const CreateSnapshotReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const CreateSnapshotReq& __x, const CreateSnapshotReq& __y) { + return !(__x < __y); + } +#endif + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< CreateSnapshotReq >; + friend void swap(CreateSnapshotReq& a, CreateSnapshotReq& b); +}; + +template +uint32_t CreateSnapshotReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class DropSnapshotReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = DropSnapshotReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + DropSnapshotReq() {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + DropSnapshotReq(apache::thrift::FragileConstructor, ::std::string name__arg); + + DropSnapshotReq(DropSnapshotReq&&) = default; + + DropSnapshotReq(const DropSnapshotReq&) = default; + + + DropSnapshotReq& operator=(DropSnapshotReq&&) = default; + + DropSnapshotReq& operator=(const DropSnapshotReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::std::string name; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool name; + } __isset = {}; + bool operator==(const DropSnapshotReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const DropSnapshotReq& __x, const DropSnapshotReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const DropSnapshotReq& rhs) const; +#ifndef SWIG + friend bool operator>(const DropSnapshotReq& __x, const DropSnapshotReq& __y) { + return __y < __x; + } + friend bool operator<=(const DropSnapshotReq& __x, const DropSnapshotReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const DropSnapshotReq& __x, const DropSnapshotReq& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref name_ref() const& { + return {this->name, __isset.name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref name_ref() const&& { + return {std::move(this->name), __isset.name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref name_ref() & { + return {this->name, __isset.name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref name_ref() && { + return {std::move(this->name), __isset.name}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + const ::std::string& get_name() const& { + return name; + } + + ::std::string get_name() && { + return std::move(name); + } + + template + ::std::string& set_name(T_DropSnapshotReq_name_struct_setter&& name_) { + name = std::forward(name_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.name = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return name; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< DropSnapshotReq >; + friend void swap(DropSnapshotReq& a, DropSnapshotReq& b); +}; + +template +uint32_t DropSnapshotReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class ListSnapshotsReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = ListSnapshotsReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + ListSnapshotsReq() {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + ListSnapshotsReq(apache::thrift::FragileConstructor); + + ListSnapshotsReq(ListSnapshotsReq&&) = default; + + ListSnapshotsReq(const ListSnapshotsReq&) = default; + + + ListSnapshotsReq& operator=(ListSnapshotsReq&&) = default; + + ListSnapshotsReq& operator=(const ListSnapshotsReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + bool operator==(const ListSnapshotsReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const ListSnapshotsReq& __x, const ListSnapshotsReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const ListSnapshotsReq& rhs) const; +#ifndef SWIG + friend bool operator>(const ListSnapshotsReq& __x, const ListSnapshotsReq& __y) { + return __y < __x; + } + friend bool operator<=(const ListSnapshotsReq& __x, const ListSnapshotsReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const ListSnapshotsReq& __x, const ListSnapshotsReq& __y) { + return !(__x < __y); + } +#endif + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< ListSnapshotsReq >; + friend void swap(ListSnapshotsReq& a, ListSnapshotsReq& b); +}; + +template +uint32_t ListSnapshotsReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class Snapshot final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = Snapshot; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + Snapshot() : + status( ::nebula::meta::cpp2::SnapshotStatus::VALID) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + Snapshot(apache::thrift::FragileConstructor, ::std::string name__arg, ::nebula::meta::cpp2::SnapshotStatus status__arg, ::std::string hosts__arg); + + Snapshot(Snapshot&&) = default; + + Snapshot(const Snapshot&) = default; + + + Snapshot& operator=(Snapshot&&) = default; + + Snapshot& operator=(const Snapshot&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::std::string name; + private: + ::nebula::meta::cpp2::SnapshotStatus status; + private: + ::std::string hosts; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool name; + bool status; + bool hosts; + } __isset = {}; + bool operator==(const Snapshot& rhs) const; +#ifndef SWIG + friend bool operator!=(const Snapshot& __x, const Snapshot& __y) { + return !(__x == __y); + } +#endif + bool operator<(const Snapshot& rhs) const; +#ifndef SWIG + friend bool operator>(const Snapshot& __x, const Snapshot& __y) { + return __y < __x; + } + friend bool operator<=(const Snapshot& __x, const Snapshot& __y) { + return !(__y < __x); + } + friend bool operator>=(const Snapshot& __x, const Snapshot& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref name_ref() const& { + return {this->name, __isset.name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref name_ref() const&& { + return {std::move(this->name), __isset.name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref name_ref() & { + return {this->name, __isset.name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref name_ref() && { + return {std::move(this->name), __isset.name}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref status_ref() const& { + return {this->status, __isset.status}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref status_ref() const&& { + return {std::move(this->status), __isset.status}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref status_ref() & { + return {this->status, __isset.status}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref status_ref() && { + return {std::move(this->status), __isset.status}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref hosts_ref() const& { + return {this->hosts, __isset.hosts}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref hosts_ref() const&& { + return {std::move(this->hosts), __isset.hosts}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref hosts_ref() & { + return {this->hosts, __isset.hosts}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref hosts_ref() && { + return {std::move(this->hosts), __isset.hosts}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + const ::std::string& get_name() const& { + return name; + } + + ::std::string get_name() && { + return std::move(name); + } + + template + ::std::string& set_name(T_Snapshot_name_struct_setter&& name_) { + name = std::forward(name_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.name = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return name; + } + + ::nebula::meta::cpp2::SnapshotStatus get_status() const { + return status; + } + + ::nebula::meta::cpp2::SnapshotStatus& set_status( ::nebula::meta::cpp2::SnapshotStatus status_) { + status = status_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.status = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return status; + } + + const ::std::string& get_hosts() const& { + return hosts; + } + + ::std::string get_hosts() && { + return std::move(hosts); + } + + template + ::std::string& set_hosts(T_Snapshot_hosts_struct_setter&& hosts_) { + hosts = std::forward(hosts_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.hosts = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return hosts; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< Snapshot >; + friend void swap(Snapshot& a, Snapshot& b); +}; + +template +uint32_t Snapshot::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class ListSnapshotsResp final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = ListSnapshotsResp; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + ListSnapshotsResp() : + code( ::nebula::cpp2::ErrorCode::SUCCEEDED) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + ListSnapshotsResp(apache::thrift::FragileConstructor, ::nebula::cpp2::ErrorCode code__arg, nebula::HostAddr leader__arg, ::std::vector< ::nebula::meta::cpp2::Snapshot> snapshots__arg); + + ListSnapshotsResp(ListSnapshotsResp&&) = default; + + ListSnapshotsResp(const ListSnapshotsResp&) = default; + + + ListSnapshotsResp& operator=(ListSnapshotsResp&&) = default; + + ListSnapshotsResp& operator=(const ListSnapshotsResp&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::ErrorCode code; + private: + nebula::HostAddr leader; + private: + ::std::vector< ::nebula::meta::cpp2::Snapshot> snapshots; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool code; + bool leader; + bool snapshots; + } __isset = {}; + bool operator==(const ListSnapshotsResp& rhs) const; +#ifndef SWIG + friend bool operator!=(const ListSnapshotsResp& __x, const ListSnapshotsResp& __y) { + return !(__x == __y); + } +#endif + bool operator<(const ListSnapshotsResp& rhs) const; +#ifndef SWIG + friend bool operator>(const ListSnapshotsResp& __x, const ListSnapshotsResp& __y) { + return __y < __x; + } + friend bool operator<=(const ListSnapshotsResp& __x, const ListSnapshotsResp& __y) { + return !(__y < __x); + } + friend bool operator>=(const ListSnapshotsResp& __x, const ListSnapshotsResp& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() const& { + return {this->code, __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() const&& { + return {std::move(this->code), __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() & { + return {this->code, __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() && { + return {std::move(this->code), __isset.code}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() const& { + return {this->leader, __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() const&& { + return {std::move(this->leader), __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() & { + return {this->leader, __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() && { + return {std::move(this->leader), __isset.leader}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::field_ref snapshots_ref() const& { + return {this->snapshots, __isset.snapshots}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref snapshots_ref() const&& { + return {std::move(this->snapshots), __isset.snapshots}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref snapshots_ref() & { + return {this->snapshots, __isset.snapshots}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref snapshots_ref() && { + return {std::move(this->snapshots), __isset.snapshots}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::ErrorCode get_code() const { + return code; + } + + ::nebula::cpp2::ErrorCode& set_code( ::nebula::cpp2::ErrorCode code_) { + code = code_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.code = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return code; + } + const nebula::HostAddr& get_leader() const&; + nebula::HostAddr get_leader() &&; + + template + nebula::HostAddr& set_leader(T_ListSnapshotsResp_leader_struct_setter&& leader_) { + leader = std::forward(leader_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.leader = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return leader; + } + const ::std::vector< ::nebula::meta::cpp2::Snapshot>& get_snapshots() const&; + ::std::vector< ::nebula::meta::cpp2::Snapshot> get_snapshots() &&; + + template > + ::std::vector< ::nebula::meta::cpp2::Snapshot>& set_snapshots(T_ListSnapshotsResp_snapshots_struct_setter&& snapshots_) { + snapshots = std::forward(snapshots_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.snapshots = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return snapshots; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< ListSnapshotsResp >; + friend void swap(ListSnapshotsResp& a, ListSnapshotsResp& b); +}; + +template +uint32_t ListSnapshotsResp::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class ListIndexStatusReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = ListIndexStatusReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + ListIndexStatusReq() : + space_id(0) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + ListIndexStatusReq(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg); + + ListIndexStatusReq(ListIndexStatusReq&&) = default; + + ListIndexStatusReq(const ListIndexStatusReq&) = default; + + + ListIndexStatusReq& operator=(ListIndexStatusReq&&) = default; + + ListIndexStatusReq& operator=(const ListIndexStatusReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::GraphSpaceID space_id; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool space_id; + } __isset = {}; + bool operator==(const ListIndexStatusReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const ListIndexStatusReq& __x, const ListIndexStatusReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const ListIndexStatusReq& rhs) const; +#ifndef SWIG + friend bool operator>(const ListIndexStatusReq& __x, const ListIndexStatusReq& __y) { + return __y < __x; + } + friend bool operator<=(const ListIndexStatusReq& __x, const ListIndexStatusReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const ListIndexStatusReq& __x, const ListIndexStatusReq& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const& { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const&& { + return {std::move(this->space_id), __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() & { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() && { + return {std::move(this->space_id), __isset.space_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::GraphSpaceID get_space_id() const { + return space_id; + } + + ::nebula::cpp2::GraphSpaceID& set_space_id( ::nebula::cpp2::GraphSpaceID space_id_) { + space_id = space_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.space_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return space_id; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< ListIndexStatusReq >; + friend void swap(ListIndexStatusReq& a, ListIndexStatusReq& b); +}; + +template +uint32_t ListIndexStatusReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class IndexStatus final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = IndexStatus; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + IndexStatus() {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + IndexStatus(apache::thrift::FragileConstructor, ::std::string name__arg, ::std::string status__arg); + + IndexStatus(IndexStatus&&) = default; + + IndexStatus(const IndexStatus&) = default; + + + IndexStatus& operator=(IndexStatus&&) = default; + + IndexStatus& operator=(const IndexStatus&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::std::string name; + private: + ::std::string status; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool name; + bool status; + } __isset = {}; + bool operator==(const IndexStatus& rhs) const; +#ifndef SWIG + friend bool operator!=(const IndexStatus& __x, const IndexStatus& __y) { + return !(__x == __y); + } +#endif + bool operator<(const IndexStatus& rhs) const; +#ifndef SWIG + friend bool operator>(const IndexStatus& __x, const IndexStatus& __y) { + return __y < __x; + } + friend bool operator<=(const IndexStatus& __x, const IndexStatus& __y) { + return !(__y < __x); + } + friend bool operator>=(const IndexStatus& __x, const IndexStatus& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref name_ref() const& { + return {this->name, __isset.name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref name_ref() const&& { + return {std::move(this->name), __isset.name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref name_ref() & { + return {this->name, __isset.name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref name_ref() && { + return {std::move(this->name), __isset.name}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref status_ref() const& { + return {this->status, __isset.status}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref status_ref() const&& { + return {std::move(this->status), __isset.status}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref status_ref() & { + return {this->status, __isset.status}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref status_ref() && { + return {std::move(this->status), __isset.status}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + const ::std::string& get_name() const& { + return name; + } + + ::std::string get_name() && { + return std::move(name); + } + + template + ::std::string& set_name(T_IndexStatus_name_struct_setter&& name_) { + name = std::forward(name_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.name = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return name; + } + + const ::std::string& get_status() const& { + return status; + } + + ::std::string get_status() && { + return std::move(status); + } + + template + ::std::string& set_status(T_IndexStatus_status_struct_setter&& status_) { + status = std::forward(status_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.status = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return status; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< IndexStatus >; + friend void swap(IndexStatus& a, IndexStatus& b); +}; + +template +uint32_t IndexStatus::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class ListIndexStatusResp final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = ListIndexStatusResp; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + ListIndexStatusResp() : + code( ::nebula::cpp2::ErrorCode::SUCCEEDED) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + ListIndexStatusResp(apache::thrift::FragileConstructor, ::nebula::cpp2::ErrorCode code__arg, nebula::HostAddr leader__arg, ::std::vector< ::nebula::meta::cpp2::IndexStatus> statuses__arg); + + ListIndexStatusResp(ListIndexStatusResp&&) = default; + + ListIndexStatusResp(const ListIndexStatusResp&) = default; + + + ListIndexStatusResp& operator=(ListIndexStatusResp&&) = default; + + ListIndexStatusResp& operator=(const ListIndexStatusResp&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::ErrorCode code; + private: + nebula::HostAddr leader; + private: + ::std::vector< ::nebula::meta::cpp2::IndexStatus> statuses; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool code; + bool leader; + bool statuses; + } __isset = {}; + bool operator==(const ListIndexStatusResp& rhs) const; +#ifndef SWIG + friend bool operator!=(const ListIndexStatusResp& __x, const ListIndexStatusResp& __y) { + return !(__x == __y); + } +#endif + bool operator<(const ListIndexStatusResp& rhs) const; +#ifndef SWIG + friend bool operator>(const ListIndexStatusResp& __x, const ListIndexStatusResp& __y) { + return __y < __x; + } + friend bool operator<=(const ListIndexStatusResp& __x, const ListIndexStatusResp& __y) { + return !(__y < __x); + } + friend bool operator>=(const ListIndexStatusResp& __x, const ListIndexStatusResp& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() const& { + return {this->code, __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() const&& { + return {std::move(this->code), __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() & { + return {this->code, __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() && { + return {std::move(this->code), __isset.code}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() const& { + return {this->leader, __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() const&& { + return {std::move(this->leader), __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() & { + return {this->leader, __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() && { + return {std::move(this->leader), __isset.leader}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::field_ref statuses_ref() const& { + return {this->statuses, __isset.statuses}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref statuses_ref() const&& { + return {std::move(this->statuses), __isset.statuses}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref statuses_ref() & { + return {this->statuses, __isset.statuses}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref statuses_ref() && { + return {std::move(this->statuses), __isset.statuses}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::ErrorCode get_code() const { + return code; + } + + ::nebula::cpp2::ErrorCode& set_code( ::nebula::cpp2::ErrorCode code_) { + code = code_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.code = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return code; + } + const nebula::HostAddr& get_leader() const&; + nebula::HostAddr get_leader() &&; + + template + nebula::HostAddr& set_leader(T_ListIndexStatusResp_leader_struct_setter&& leader_) { + leader = std::forward(leader_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.leader = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return leader; + } + const ::std::vector< ::nebula::meta::cpp2::IndexStatus>& get_statuses() const&; + ::std::vector< ::nebula::meta::cpp2::IndexStatus> get_statuses() &&; + + template > + ::std::vector< ::nebula::meta::cpp2::IndexStatus>& set_statuses(T_ListIndexStatusResp_statuses_struct_setter&& statuses_) { + statuses = std::forward(statuses_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.statuses = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return statuses; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< ListIndexStatusResp >; + friend void swap(ListIndexStatusResp& a, ListIndexStatusResp& b); +}; + +template +uint32_t ListIndexStatusResp::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class AddZoneReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = AddZoneReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + AddZoneReq() {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + AddZoneReq(apache::thrift::FragileConstructor, ::std::string zone_name__arg, ::std::vector nodes__arg); + + AddZoneReq(AddZoneReq&&) = default; + + AddZoneReq(const AddZoneReq&) = default; + + + AddZoneReq& operator=(AddZoneReq&&) = default; + + AddZoneReq& operator=(const AddZoneReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::std::string zone_name; + private: + ::std::vector nodes; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool zone_name; + bool nodes; + } __isset = {}; + bool operator==(const AddZoneReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const AddZoneReq& __x, const AddZoneReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const AddZoneReq& rhs) const; +#ifndef SWIG + friend bool operator>(const AddZoneReq& __x, const AddZoneReq& __y) { + return __y < __x; + } + friend bool operator<=(const AddZoneReq& __x, const AddZoneReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const AddZoneReq& __x, const AddZoneReq& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref zone_name_ref() const& { + return {this->zone_name, __isset.zone_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref zone_name_ref() const&& { + return {std::move(this->zone_name), __isset.zone_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref zone_name_ref() & { + return {this->zone_name, __isset.zone_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref zone_name_ref() && { + return {std::move(this->zone_name), __isset.zone_name}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::field_ref nodes_ref() const& { + return {this->nodes, __isset.nodes}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref nodes_ref() const&& { + return {std::move(this->nodes), __isset.nodes}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref nodes_ref() & { + return {this->nodes, __isset.nodes}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref nodes_ref() && { + return {std::move(this->nodes), __isset.nodes}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + const ::std::string& get_zone_name() const& { + return zone_name; + } + + ::std::string get_zone_name() && { + return std::move(zone_name); + } + + template + ::std::string& set_zone_name(T_AddZoneReq_zone_name_struct_setter&& zone_name_) { + zone_name = std::forward(zone_name_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.zone_name = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return zone_name; + } + const ::std::vector& get_nodes() const&; + ::std::vector get_nodes() &&; + + template > + ::std::vector& set_nodes(T_AddZoneReq_nodes_struct_setter&& nodes_) { + nodes = std::forward(nodes_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.nodes = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return nodes; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< AddZoneReq >; + friend void swap(AddZoneReq& a, AddZoneReq& b); +}; + +template +uint32_t AddZoneReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class DropZoneReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = DropZoneReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + DropZoneReq() {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + DropZoneReq(apache::thrift::FragileConstructor, ::std::string zone_name__arg); + + DropZoneReq(DropZoneReq&&) = default; + + DropZoneReq(const DropZoneReq&) = default; + + + DropZoneReq& operator=(DropZoneReq&&) = default; + + DropZoneReq& operator=(const DropZoneReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::std::string zone_name; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool zone_name; + } __isset = {}; + bool operator==(const DropZoneReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const DropZoneReq& __x, const DropZoneReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const DropZoneReq& rhs) const; +#ifndef SWIG + friend bool operator>(const DropZoneReq& __x, const DropZoneReq& __y) { + return __y < __x; + } + friend bool operator<=(const DropZoneReq& __x, const DropZoneReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const DropZoneReq& __x, const DropZoneReq& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref zone_name_ref() const& { + return {this->zone_name, __isset.zone_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref zone_name_ref() const&& { + return {std::move(this->zone_name), __isset.zone_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref zone_name_ref() & { + return {this->zone_name, __isset.zone_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref zone_name_ref() && { + return {std::move(this->zone_name), __isset.zone_name}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + const ::std::string& get_zone_name() const& { + return zone_name; + } + + ::std::string get_zone_name() && { + return std::move(zone_name); + } + + template + ::std::string& set_zone_name(T_DropZoneReq_zone_name_struct_setter&& zone_name_) { + zone_name = std::forward(zone_name_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.zone_name = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return zone_name; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< DropZoneReq >; + friend void swap(DropZoneReq& a, DropZoneReq& b); +}; + +template +uint32_t DropZoneReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class AddHostIntoZoneReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = AddHostIntoZoneReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + AddHostIntoZoneReq() {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + AddHostIntoZoneReq(apache::thrift::FragileConstructor, nebula::HostAddr node__arg, ::std::string zone_name__arg); + + AddHostIntoZoneReq(AddHostIntoZoneReq&&) = default; + + AddHostIntoZoneReq(const AddHostIntoZoneReq&) = default; + + + AddHostIntoZoneReq& operator=(AddHostIntoZoneReq&&) = default; + + AddHostIntoZoneReq& operator=(const AddHostIntoZoneReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + nebula::HostAddr node; + private: + ::std::string zone_name; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool node; + bool zone_name; + } __isset = {}; + bool operator==(const AddHostIntoZoneReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const AddHostIntoZoneReq& __x, const AddHostIntoZoneReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const AddHostIntoZoneReq& rhs) const; +#ifndef SWIG + friend bool operator>(const AddHostIntoZoneReq& __x, const AddHostIntoZoneReq& __y) { + return __y < __x; + } + friend bool operator<=(const AddHostIntoZoneReq& __x, const AddHostIntoZoneReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const AddHostIntoZoneReq& __x, const AddHostIntoZoneReq& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref node_ref() const& { + return {this->node, __isset.node}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref node_ref() const&& { + return {std::move(this->node), __isset.node}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref node_ref() & { + return {this->node, __isset.node}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref node_ref() && { + return {std::move(this->node), __isset.node}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref zone_name_ref() const& { + return {this->zone_name, __isset.zone_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref zone_name_ref() const&& { + return {std::move(this->zone_name), __isset.zone_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref zone_name_ref() & { + return {this->zone_name, __isset.zone_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref zone_name_ref() && { + return {std::move(this->zone_name), __isset.zone_name}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + const nebula::HostAddr& get_node() const&; + nebula::HostAddr get_node() &&; + + template + nebula::HostAddr& set_node(T_AddHostIntoZoneReq_node_struct_setter&& node_) { + node = std::forward(node_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.node = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return node; + } + + const ::std::string& get_zone_name() const& { + return zone_name; + } + + ::std::string get_zone_name() && { + return std::move(zone_name); + } + + template + ::std::string& set_zone_name(T_AddHostIntoZoneReq_zone_name_struct_setter&& zone_name_) { + zone_name = std::forward(zone_name_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.zone_name = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return zone_name; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< AddHostIntoZoneReq >; + friend void swap(AddHostIntoZoneReq& a, AddHostIntoZoneReq& b); +}; + +template +uint32_t AddHostIntoZoneReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class DropHostFromZoneReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = DropHostFromZoneReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + DropHostFromZoneReq() {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + DropHostFromZoneReq(apache::thrift::FragileConstructor, nebula::HostAddr node__arg, ::std::string zone_name__arg); + + DropHostFromZoneReq(DropHostFromZoneReq&&) = default; + + DropHostFromZoneReq(const DropHostFromZoneReq&) = default; + + + DropHostFromZoneReq& operator=(DropHostFromZoneReq&&) = default; + + DropHostFromZoneReq& operator=(const DropHostFromZoneReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + nebula::HostAddr node; + private: + ::std::string zone_name; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool node; + bool zone_name; + } __isset = {}; + bool operator==(const DropHostFromZoneReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const DropHostFromZoneReq& __x, const DropHostFromZoneReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const DropHostFromZoneReq& rhs) const; +#ifndef SWIG + friend bool operator>(const DropHostFromZoneReq& __x, const DropHostFromZoneReq& __y) { + return __y < __x; + } + friend bool operator<=(const DropHostFromZoneReq& __x, const DropHostFromZoneReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const DropHostFromZoneReq& __x, const DropHostFromZoneReq& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref node_ref() const& { + return {this->node, __isset.node}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref node_ref() const&& { + return {std::move(this->node), __isset.node}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref node_ref() & { + return {this->node, __isset.node}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref node_ref() && { + return {std::move(this->node), __isset.node}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref zone_name_ref() const& { + return {this->zone_name, __isset.zone_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref zone_name_ref() const&& { + return {std::move(this->zone_name), __isset.zone_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref zone_name_ref() & { + return {this->zone_name, __isset.zone_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref zone_name_ref() && { + return {std::move(this->zone_name), __isset.zone_name}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + const nebula::HostAddr& get_node() const&; + nebula::HostAddr get_node() &&; + + template + nebula::HostAddr& set_node(T_DropHostFromZoneReq_node_struct_setter&& node_) { + node = std::forward(node_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.node = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return node; + } + + const ::std::string& get_zone_name() const& { + return zone_name; + } + + ::std::string get_zone_name() && { + return std::move(zone_name); + } + + template + ::std::string& set_zone_name(T_DropHostFromZoneReq_zone_name_struct_setter&& zone_name_) { + zone_name = std::forward(zone_name_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.zone_name = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return zone_name; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< DropHostFromZoneReq >; + friend void swap(DropHostFromZoneReq& a, DropHostFromZoneReq& b); +}; + +template +uint32_t DropHostFromZoneReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class GetZoneReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = GetZoneReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + GetZoneReq() {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + GetZoneReq(apache::thrift::FragileConstructor, ::std::string zone_name__arg); + + GetZoneReq(GetZoneReq&&) = default; + + GetZoneReq(const GetZoneReq&) = default; + + + GetZoneReq& operator=(GetZoneReq&&) = default; + + GetZoneReq& operator=(const GetZoneReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::std::string zone_name; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool zone_name; + } __isset = {}; + bool operator==(const GetZoneReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const GetZoneReq& __x, const GetZoneReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const GetZoneReq& rhs) const; +#ifndef SWIG + friend bool operator>(const GetZoneReq& __x, const GetZoneReq& __y) { + return __y < __x; + } + friend bool operator<=(const GetZoneReq& __x, const GetZoneReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const GetZoneReq& __x, const GetZoneReq& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref zone_name_ref() const& { + return {this->zone_name, __isset.zone_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref zone_name_ref() const&& { + return {std::move(this->zone_name), __isset.zone_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref zone_name_ref() & { + return {this->zone_name, __isset.zone_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref zone_name_ref() && { + return {std::move(this->zone_name), __isset.zone_name}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + const ::std::string& get_zone_name() const& { + return zone_name; + } + + ::std::string get_zone_name() && { + return std::move(zone_name); + } + + template + ::std::string& set_zone_name(T_GetZoneReq_zone_name_struct_setter&& zone_name_) { + zone_name = std::forward(zone_name_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.zone_name = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return zone_name; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< GetZoneReq >; + friend void swap(GetZoneReq& a, GetZoneReq& b); +}; + +template +uint32_t GetZoneReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class GetZoneResp final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = GetZoneResp; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + GetZoneResp() : + code( ::nebula::cpp2::ErrorCode::SUCCEEDED) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + GetZoneResp(apache::thrift::FragileConstructor, ::nebula::cpp2::ErrorCode code__arg, nebula::HostAddr leader__arg, ::std::vector hosts__arg); + + GetZoneResp(GetZoneResp&&) = default; + + GetZoneResp(const GetZoneResp&) = default; + + + GetZoneResp& operator=(GetZoneResp&&) = default; + + GetZoneResp& operator=(const GetZoneResp&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::ErrorCode code; + private: + nebula::HostAddr leader; + private: + ::std::vector hosts; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool code; + bool leader; + bool hosts; + } __isset = {}; + bool operator==(const GetZoneResp& rhs) const; +#ifndef SWIG + friend bool operator!=(const GetZoneResp& __x, const GetZoneResp& __y) { + return !(__x == __y); + } +#endif + bool operator<(const GetZoneResp& rhs) const; +#ifndef SWIG + friend bool operator>(const GetZoneResp& __x, const GetZoneResp& __y) { + return __y < __x; + } + friend bool operator<=(const GetZoneResp& __x, const GetZoneResp& __y) { + return !(__y < __x); + } + friend bool operator>=(const GetZoneResp& __x, const GetZoneResp& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() const& { + return {this->code, __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() const&& { + return {std::move(this->code), __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() & { + return {this->code, __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() && { + return {std::move(this->code), __isset.code}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() const& { + return {this->leader, __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() const&& { + return {std::move(this->leader), __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() & { + return {this->leader, __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() && { + return {std::move(this->leader), __isset.leader}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::field_ref hosts_ref() const& { + return {this->hosts, __isset.hosts}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref hosts_ref() const&& { + return {std::move(this->hosts), __isset.hosts}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref hosts_ref() & { + return {this->hosts, __isset.hosts}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref hosts_ref() && { + return {std::move(this->hosts), __isset.hosts}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::ErrorCode get_code() const { + return code; + } + + ::nebula::cpp2::ErrorCode& set_code( ::nebula::cpp2::ErrorCode code_) { + code = code_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.code = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return code; + } + const nebula::HostAddr& get_leader() const&; + nebula::HostAddr get_leader() &&; + + template + nebula::HostAddr& set_leader(T_GetZoneResp_leader_struct_setter&& leader_) { + leader = std::forward(leader_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.leader = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return leader; + } + const ::std::vector& get_hosts() const&; + ::std::vector get_hosts() &&; + + template > + ::std::vector& set_hosts(T_GetZoneResp_hosts_struct_setter&& hosts_) { + hosts = std::forward(hosts_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.hosts = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return hosts; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< GetZoneResp >; + friend void swap(GetZoneResp& a, GetZoneResp& b); +}; + +template +uint32_t GetZoneResp::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class ListZonesReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = ListZonesReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + ListZonesReq() {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + ListZonesReq(apache::thrift::FragileConstructor); + + ListZonesReq(ListZonesReq&&) = default; + + ListZonesReq(const ListZonesReq&) = default; + + + ListZonesReq& operator=(ListZonesReq&&) = default; + + ListZonesReq& operator=(const ListZonesReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + bool operator==(const ListZonesReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const ListZonesReq& __x, const ListZonesReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const ListZonesReq& rhs) const; +#ifndef SWIG + friend bool operator>(const ListZonesReq& __x, const ListZonesReq& __y) { + return __y < __x; + } + friend bool operator<=(const ListZonesReq& __x, const ListZonesReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const ListZonesReq& __x, const ListZonesReq& __y) { + return !(__x < __y); + } +#endif + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< ListZonesReq >; + friend void swap(ListZonesReq& a, ListZonesReq& b); +}; + +template +uint32_t ListZonesReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class Zone final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = Zone; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + Zone() {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + Zone(apache::thrift::FragileConstructor, ::std::string zone_name__arg, ::std::vector nodes__arg); + + Zone(Zone&&) = default; + + Zone(const Zone&) = default; + + + Zone& operator=(Zone&&) = default; + + Zone& operator=(const Zone&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::std::string zone_name; + private: + ::std::vector nodes; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool zone_name; + bool nodes; + } __isset = {}; + bool operator==(const Zone& rhs) const; +#ifndef SWIG + friend bool operator!=(const Zone& __x, const Zone& __y) { + return !(__x == __y); + } +#endif + bool operator<(const Zone& rhs) const; +#ifndef SWIG + friend bool operator>(const Zone& __x, const Zone& __y) { + return __y < __x; + } + friend bool operator<=(const Zone& __x, const Zone& __y) { + return !(__y < __x); + } + friend bool operator>=(const Zone& __x, const Zone& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref zone_name_ref() const& { + return {this->zone_name, __isset.zone_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref zone_name_ref() const&& { + return {std::move(this->zone_name), __isset.zone_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref zone_name_ref() & { + return {this->zone_name, __isset.zone_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref zone_name_ref() && { + return {std::move(this->zone_name), __isset.zone_name}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::field_ref nodes_ref() const& { + return {this->nodes, __isset.nodes}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref nodes_ref() const&& { + return {std::move(this->nodes), __isset.nodes}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref nodes_ref() & { + return {this->nodes, __isset.nodes}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref nodes_ref() && { + return {std::move(this->nodes), __isset.nodes}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + const ::std::string& get_zone_name() const& { + return zone_name; + } + + ::std::string get_zone_name() && { + return std::move(zone_name); + } + + template + ::std::string& set_zone_name(T_Zone_zone_name_struct_setter&& zone_name_) { + zone_name = std::forward(zone_name_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.zone_name = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return zone_name; + } + const ::std::vector& get_nodes() const&; + ::std::vector get_nodes() &&; + + template > + ::std::vector& set_nodes(T_Zone_nodes_struct_setter&& nodes_) { + nodes = std::forward(nodes_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.nodes = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return nodes; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< Zone >; + friend void swap(Zone& a, Zone& b); +}; + +template +uint32_t Zone::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class ListZonesResp final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = ListZonesResp; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + ListZonesResp() : + code( ::nebula::cpp2::ErrorCode::SUCCEEDED) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + ListZonesResp(apache::thrift::FragileConstructor, ::nebula::cpp2::ErrorCode code__arg, nebula::HostAddr leader__arg, ::std::vector< ::nebula::meta::cpp2::Zone> zones__arg); + + ListZonesResp(ListZonesResp&&) = default; + + ListZonesResp(const ListZonesResp&) = default; + + + ListZonesResp& operator=(ListZonesResp&&) = default; + + ListZonesResp& operator=(const ListZonesResp&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::ErrorCode code; + private: + nebula::HostAddr leader; + private: + ::std::vector< ::nebula::meta::cpp2::Zone> zones; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool code; + bool leader; + bool zones; + } __isset = {}; + bool operator==(const ListZonesResp& rhs) const; +#ifndef SWIG + friend bool operator!=(const ListZonesResp& __x, const ListZonesResp& __y) { + return !(__x == __y); + } +#endif + bool operator<(const ListZonesResp& rhs) const; +#ifndef SWIG + friend bool operator>(const ListZonesResp& __x, const ListZonesResp& __y) { + return __y < __x; + } + friend bool operator<=(const ListZonesResp& __x, const ListZonesResp& __y) { + return !(__y < __x); + } + friend bool operator>=(const ListZonesResp& __x, const ListZonesResp& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() const& { + return {this->code, __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() const&& { + return {std::move(this->code), __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() & { + return {this->code, __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() && { + return {std::move(this->code), __isset.code}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() const& { + return {this->leader, __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() const&& { + return {std::move(this->leader), __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() & { + return {this->leader, __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() && { + return {std::move(this->leader), __isset.leader}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::field_ref zones_ref() const& { + return {this->zones, __isset.zones}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref zones_ref() const&& { + return {std::move(this->zones), __isset.zones}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref zones_ref() & { + return {this->zones, __isset.zones}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref zones_ref() && { + return {std::move(this->zones), __isset.zones}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::ErrorCode get_code() const { + return code; + } + + ::nebula::cpp2::ErrorCode& set_code( ::nebula::cpp2::ErrorCode code_) { + code = code_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.code = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return code; + } + const nebula::HostAddr& get_leader() const&; + nebula::HostAddr get_leader() &&; + + template + nebula::HostAddr& set_leader(T_ListZonesResp_leader_struct_setter&& leader_) { + leader = std::forward(leader_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.leader = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return leader; + } + const ::std::vector< ::nebula::meta::cpp2::Zone>& get_zones() const&; + ::std::vector< ::nebula::meta::cpp2::Zone> get_zones() &&; + + template > + ::std::vector< ::nebula::meta::cpp2::Zone>& set_zones(T_ListZonesResp_zones_struct_setter&& zones_) { + zones = std::forward(zones_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.zones = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return zones; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< ListZonesResp >; + friend void swap(ListZonesResp& a, ListZonesResp& b); +}; + +template +uint32_t ListZonesResp::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class AddGroupReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = AddGroupReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + AddGroupReq() {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + AddGroupReq(apache::thrift::FragileConstructor, ::std::string group_name__arg, ::std::vector<::std::string> zone_names__arg); + + AddGroupReq(AddGroupReq&&) = default; + + AddGroupReq(const AddGroupReq&) = default; + + + AddGroupReq& operator=(AddGroupReq&&) = default; + + AddGroupReq& operator=(const AddGroupReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::std::string group_name; + private: + ::std::vector<::std::string> zone_names; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool group_name; + bool zone_names; + } __isset = {}; + bool operator==(const AddGroupReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const AddGroupReq& __x, const AddGroupReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const AddGroupReq& rhs) const; +#ifndef SWIG + friend bool operator>(const AddGroupReq& __x, const AddGroupReq& __y) { + return __y < __x; + } + friend bool operator<=(const AddGroupReq& __x, const AddGroupReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const AddGroupReq& __x, const AddGroupReq& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref group_name_ref() const& { + return {this->group_name, __isset.group_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref group_name_ref() const&& { + return {std::move(this->group_name), __isset.group_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref group_name_ref() & { + return {this->group_name, __isset.group_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref group_name_ref() && { + return {std::move(this->group_name), __isset.group_name}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::field_ref zone_names_ref() const& { + return {this->zone_names, __isset.zone_names}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref zone_names_ref() const&& { + return {std::move(this->zone_names), __isset.zone_names}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref zone_names_ref() & { + return {this->zone_names, __isset.zone_names}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref zone_names_ref() && { + return {std::move(this->zone_names), __isset.zone_names}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + const ::std::string& get_group_name() const& { + return group_name; + } + + ::std::string get_group_name() && { + return std::move(group_name); + } + + template + ::std::string& set_group_name(T_AddGroupReq_group_name_struct_setter&& group_name_) { + group_name = std::forward(group_name_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.group_name = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return group_name; + } + const ::std::vector<::std::string>& get_zone_names() const&; + ::std::vector<::std::string> get_zone_names() &&; + + template > + ::std::vector<::std::string>& set_zone_names(T_AddGroupReq_zone_names_struct_setter&& zone_names_) { + zone_names = std::forward(zone_names_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.zone_names = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return zone_names; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< AddGroupReq >; + friend void swap(AddGroupReq& a, AddGroupReq& b); +}; + +template +uint32_t AddGroupReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class DropGroupReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = DropGroupReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + DropGroupReq() {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + DropGroupReq(apache::thrift::FragileConstructor, ::std::string group_name__arg); + + DropGroupReq(DropGroupReq&&) = default; + + DropGroupReq(const DropGroupReq&) = default; + + + DropGroupReq& operator=(DropGroupReq&&) = default; + + DropGroupReq& operator=(const DropGroupReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::std::string group_name; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool group_name; + } __isset = {}; + bool operator==(const DropGroupReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const DropGroupReq& __x, const DropGroupReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const DropGroupReq& rhs) const; +#ifndef SWIG + friend bool operator>(const DropGroupReq& __x, const DropGroupReq& __y) { + return __y < __x; + } + friend bool operator<=(const DropGroupReq& __x, const DropGroupReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const DropGroupReq& __x, const DropGroupReq& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref group_name_ref() const& { + return {this->group_name, __isset.group_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref group_name_ref() const&& { + return {std::move(this->group_name), __isset.group_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref group_name_ref() & { + return {this->group_name, __isset.group_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref group_name_ref() && { + return {std::move(this->group_name), __isset.group_name}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + const ::std::string& get_group_name() const& { + return group_name; + } + + ::std::string get_group_name() && { + return std::move(group_name); + } + + template + ::std::string& set_group_name(T_DropGroupReq_group_name_struct_setter&& group_name_) { + group_name = std::forward(group_name_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.group_name = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return group_name; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< DropGroupReq >; + friend void swap(DropGroupReq& a, DropGroupReq& b); +}; + +template +uint32_t DropGroupReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class AddZoneIntoGroupReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = AddZoneIntoGroupReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + AddZoneIntoGroupReq() {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + AddZoneIntoGroupReq(apache::thrift::FragileConstructor, ::std::string zone_name__arg, ::std::string group_name__arg); + + AddZoneIntoGroupReq(AddZoneIntoGroupReq&&) = default; + + AddZoneIntoGroupReq(const AddZoneIntoGroupReq&) = default; + + + AddZoneIntoGroupReq& operator=(AddZoneIntoGroupReq&&) = default; + + AddZoneIntoGroupReq& operator=(const AddZoneIntoGroupReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::std::string zone_name; + private: + ::std::string group_name; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool zone_name; + bool group_name; + } __isset = {}; + bool operator==(const AddZoneIntoGroupReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const AddZoneIntoGroupReq& __x, const AddZoneIntoGroupReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const AddZoneIntoGroupReq& rhs) const; +#ifndef SWIG + friend bool operator>(const AddZoneIntoGroupReq& __x, const AddZoneIntoGroupReq& __y) { + return __y < __x; + } + friend bool operator<=(const AddZoneIntoGroupReq& __x, const AddZoneIntoGroupReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const AddZoneIntoGroupReq& __x, const AddZoneIntoGroupReq& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref zone_name_ref() const& { + return {this->zone_name, __isset.zone_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref zone_name_ref() const&& { + return {std::move(this->zone_name), __isset.zone_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref zone_name_ref() & { + return {this->zone_name, __isset.zone_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref zone_name_ref() && { + return {std::move(this->zone_name), __isset.zone_name}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref group_name_ref() const& { + return {this->group_name, __isset.group_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref group_name_ref() const&& { + return {std::move(this->group_name), __isset.group_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref group_name_ref() & { + return {this->group_name, __isset.group_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref group_name_ref() && { + return {std::move(this->group_name), __isset.group_name}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + const ::std::string& get_zone_name() const& { + return zone_name; + } + + ::std::string get_zone_name() && { + return std::move(zone_name); + } + + template + ::std::string& set_zone_name(T_AddZoneIntoGroupReq_zone_name_struct_setter&& zone_name_) { + zone_name = std::forward(zone_name_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.zone_name = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return zone_name; + } + + const ::std::string& get_group_name() const& { + return group_name; + } + + ::std::string get_group_name() && { + return std::move(group_name); + } + + template + ::std::string& set_group_name(T_AddZoneIntoGroupReq_group_name_struct_setter&& group_name_) { + group_name = std::forward(group_name_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.group_name = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return group_name; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< AddZoneIntoGroupReq >; + friend void swap(AddZoneIntoGroupReq& a, AddZoneIntoGroupReq& b); +}; + +template +uint32_t AddZoneIntoGroupReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class DropZoneFromGroupReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = DropZoneFromGroupReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + DropZoneFromGroupReq() {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + DropZoneFromGroupReq(apache::thrift::FragileConstructor, ::std::string zone_name__arg, ::std::string group_name__arg); + + DropZoneFromGroupReq(DropZoneFromGroupReq&&) = default; + + DropZoneFromGroupReq(const DropZoneFromGroupReq&) = default; + + + DropZoneFromGroupReq& operator=(DropZoneFromGroupReq&&) = default; + + DropZoneFromGroupReq& operator=(const DropZoneFromGroupReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::std::string zone_name; + private: + ::std::string group_name; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool zone_name; + bool group_name; + } __isset = {}; + bool operator==(const DropZoneFromGroupReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const DropZoneFromGroupReq& __x, const DropZoneFromGroupReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const DropZoneFromGroupReq& rhs) const; +#ifndef SWIG + friend bool operator>(const DropZoneFromGroupReq& __x, const DropZoneFromGroupReq& __y) { + return __y < __x; + } + friend bool operator<=(const DropZoneFromGroupReq& __x, const DropZoneFromGroupReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const DropZoneFromGroupReq& __x, const DropZoneFromGroupReq& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref zone_name_ref() const& { + return {this->zone_name, __isset.zone_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref zone_name_ref() const&& { + return {std::move(this->zone_name), __isset.zone_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref zone_name_ref() & { + return {this->zone_name, __isset.zone_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref zone_name_ref() && { + return {std::move(this->zone_name), __isset.zone_name}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref group_name_ref() const& { + return {this->group_name, __isset.group_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref group_name_ref() const&& { + return {std::move(this->group_name), __isset.group_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref group_name_ref() & { + return {this->group_name, __isset.group_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref group_name_ref() && { + return {std::move(this->group_name), __isset.group_name}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + const ::std::string& get_zone_name() const& { + return zone_name; + } + + ::std::string get_zone_name() && { + return std::move(zone_name); + } + + template + ::std::string& set_zone_name(T_DropZoneFromGroupReq_zone_name_struct_setter&& zone_name_) { + zone_name = std::forward(zone_name_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.zone_name = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return zone_name; + } + + const ::std::string& get_group_name() const& { + return group_name; + } + + ::std::string get_group_name() && { + return std::move(group_name); + } + + template + ::std::string& set_group_name(T_DropZoneFromGroupReq_group_name_struct_setter&& group_name_) { + group_name = std::forward(group_name_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.group_name = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return group_name; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< DropZoneFromGroupReq >; + friend void swap(DropZoneFromGroupReq& a, DropZoneFromGroupReq& b); +}; + +template +uint32_t DropZoneFromGroupReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class GetGroupReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = GetGroupReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + GetGroupReq() {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + GetGroupReq(apache::thrift::FragileConstructor, ::std::string group_name__arg); + + GetGroupReq(GetGroupReq&&) = default; + + GetGroupReq(const GetGroupReq&) = default; + + + GetGroupReq& operator=(GetGroupReq&&) = default; + + GetGroupReq& operator=(const GetGroupReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::std::string group_name; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool group_name; + } __isset = {}; + bool operator==(const GetGroupReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const GetGroupReq& __x, const GetGroupReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const GetGroupReq& rhs) const; +#ifndef SWIG + friend bool operator>(const GetGroupReq& __x, const GetGroupReq& __y) { + return __y < __x; + } + friend bool operator<=(const GetGroupReq& __x, const GetGroupReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const GetGroupReq& __x, const GetGroupReq& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref group_name_ref() const& { + return {this->group_name, __isset.group_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref group_name_ref() const&& { + return {std::move(this->group_name), __isset.group_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref group_name_ref() & { + return {this->group_name, __isset.group_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref group_name_ref() && { + return {std::move(this->group_name), __isset.group_name}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + const ::std::string& get_group_name() const& { + return group_name; + } + + ::std::string get_group_name() && { + return std::move(group_name); + } + + template + ::std::string& set_group_name(T_GetGroupReq_group_name_struct_setter&& group_name_) { + group_name = std::forward(group_name_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.group_name = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return group_name; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< GetGroupReq >; + friend void swap(GetGroupReq& a, GetGroupReq& b); +}; + +template +uint32_t GetGroupReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class GetGroupResp final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = GetGroupResp; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + GetGroupResp() : + code( ::nebula::cpp2::ErrorCode::SUCCEEDED) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + GetGroupResp(apache::thrift::FragileConstructor, ::nebula::cpp2::ErrorCode code__arg, nebula::HostAddr leader__arg, ::std::vector<::std::string> zone_names__arg); + + GetGroupResp(GetGroupResp&&) = default; + + GetGroupResp(const GetGroupResp&) = default; + + + GetGroupResp& operator=(GetGroupResp&&) = default; + + GetGroupResp& operator=(const GetGroupResp&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::ErrorCode code; + private: + nebula::HostAddr leader; + private: + ::std::vector<::std::string> zone_names; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool code; + bool leader; + bool zone_names; + } __isset = {}; + bool operator==(const GetGroupResp& rhs) const; +#ifndef SWIG + friend bool operator!=(const GetGroupResp& __x, const GetGroupResp& __y) { + return !(__x == __y); + } +#endif + bool operator<(const GetGroupResp& rhs) const; +#ifndef SWIG + friend bool operator>(const GetGroupResp& __x, const GetGroupResp& __y) { + return __y < __x; + } + friend bool operator<=(const GetGroupResp& __x, const GetGroupResp& __y) { + return !(__y < __x); + } + friend bool operator>=(const GetGroupResp& __x, const GetGroupResp& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() const& { + return {this->code, __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() const&& { + return {std::move(this->code), __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() & { + return {this->code, __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() && { + return {std::move(this->code), __isset.code}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() const& { + return {this->leader, __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() const&& { + return {std::move(this->leader), __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() & { + return {this->leader, __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() && { + return {std::move(this->leader), __isset.leader}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::field_ref zone_names_ref() const& { + return {this->zone_names, __isset.zone_names}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref zone_names_ref() const&& { + return {std::move(this->zone_names), __isset.zone_names}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref zone_names_ref() & { + return {this->zone_names, __isset.zone_names}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref zone_names_ref() && { + return {std::move(this->zone_names), __isset.zone_names}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::ErrorCode get_code() const { + return code; + } + + ::nebula::cpp2::ErrorCode& set_code( ::nebula::cpp2::ErrorCode code_) { + code = code_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.code = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return code; + } + const nebula::HostAddr& get_leader() const&; + nebula::HostAddr get_leader() &&; + + template + nebula::HostAddr& set_leader(T_GetGroupResp_leader_struct_setter&& leader_) { + leader = std::forward(leader_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.leader = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return leader; + } + const ::std::vector<::std::string>& get_zone_names() const&; + ::std::vector<::std::string> get_zone_names() &&; + + template > + ::std::vector<::std::string>& set_zone_names(T_GetGroupResp_zone_names_struct_setter&& zone_names_) { + zone_names = std::forward(zone_names_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.zone_names = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return zone_names; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< GetGroupResp >; + friend void swap(GetGroupResp& a, GetGroupResp& b); +}; + +template +uint32_t GetGroupResp::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class ListGroupsReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = ListGroupsReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + ListGroupsReq() {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + ListGroupsReq(apache::thrift::FragileConstructor); + + ListGroupsReq(ListGroupsReq&&) = default; + + ListGroupsReq(const ListGroupsReq&) = default; + + + ListGroupsReq& operator=(ListGroupsReq&&) = default; + + ListGroupsReq& operator=(const ListGroupsReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + bool operator==(const ListGroupsReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const ListGroupsReq& __x, const ListGroupsReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const ListGroupsReq& rhs) const; +#ifndef SWIG + friend bool operator>(const ListGroupsReq& __x, const ListGroupsReq& __y) { + return __y < __x; + } + friend bool operator<=(const ListGroupsReq& __x, const ListGroupsReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const ListGroupsReq& __x, const ListGroupsReq& __y) { + return !(__x < __y); + } +#endif + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< ListGroupsReq >; + friend void swap(ListGroupsReq& a, ListGroupsReq& b); +}; + +template +uint32_t ListGroupsReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class Group final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = Group; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + Group() {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + Group(apache::thrift::FragileConstructor, ::std::string group_name__arg, ::std::vector<::std::string> zone_names__arg); + + Group(Group&&) = default; + + Group(const Group&) = default; + + + Group& operator=(Group&&) = default; + + Group& operator=(const Group&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::std::string group_name; + private: + ::std::vector<::std::string> zone_names; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool group_name; + bool zone_names; + } __isset = {}; + bool operator==(const Group& rhs) const; +#ifndef SWIG + friend bool operator!=(const Group& __x, const Group& __y) { + return !(__x == __y); + } +#endif + bool operator<(const Group& rhs) const; +#ifndef SWIG + friend bool operator>(const Group& __x, const Group& __y) { + return __y < __x; + } + friend bool operator<=(const Group& __x, const Group& __y) { + return !(__y < __x); + } + friend bool operator>=(const Group& __x, const Group& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref group_name_ref() const& { + return {this->group_name, __isset.group_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref group_name_ref() const&& { + return {std::move(this->group_name), __isset.group_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref group_name_ref() & { + return {this->group_name, __isset.group_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref group_name_ref() && { + return {std::move(this->group_name), __isset.group_name}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::field_ref zone_names_ref() const& { + return {this->zone_names, __isset.zone_names}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref zone_names_ref() const&& { + return {std::move(this->zone_names), __isset.zone_names}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref zone_names_ref() & { + return {this->zone_names, __isset.zone_names}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref zone_names_ref() && { + return {std::move(this->zone_names), __isset.zone_names}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + const ::std::string& get_group_name() const& { + return group_name; + } + + ::std::string get_group_name() && { + return std::move(group_name); + } + + template + ::std::string& set_group_name(T_Group_group_name_struct_setter&& group_name_) { + group_name = std::forward(group_name_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.group_name = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return group_name; + } + const ::std::vector<::std::string>& get_zone_names() const&; + ::std::vector<::std::string> get_zone_names() &&; + + template > + ::std::vector<::std::string>& set_zone_names(T_Group_zone_names_struct_setter&& zone_names_) { + zone_names = std::forward(zone_names_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.zone_names = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return zone_names; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< Group >; + friend void swap(Group& a, Group& b); +}; + +template +uint32_t Group::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class ListGroupsResp final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = ListGroupsResp; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + ListGroupsResp() : + code( ::nebula::cpp2::ErrorCode::SUCCEEDED) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + ListGroupsResp(apache::thrift::FragileConstructor, ::nebula::cpp2::ErrorCode code__arg, nebula::HostAddr leader__arg, ::std::vector< ::nebula::meta::cpp2::Group> groups__arg); + + ListGroupsResp(ListGroupsResp&&) = default; + + ListGroupsResp(const ListGroupsResp&) = default; + + + ListGroupsResp& operator=(ListGroupsResp&&) = default; + + ListGroupsResp& operator=(const ListGroupsResp&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::ErrorCode code; + private: + nebula::HostAddr leader; + private: + ::std::vector< ::nebula::meta::cpp2::Group> groups; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool code; + bool leader; + bool groups; + } __isset = {}; + bool operator==(const ListGroupsResp& rhs) const; +#ifndef SWIG + friend bool operator!=(const ListGroupsResp& __x, const ListGroupsResp& __y) { + return !(__x == __y); + } +#endif + bool operator<(const ListGroupsResp& rhs) const; +#ifndef SWIG + friend bool operator>(const ListGroupsResp& __x, const ListGroupsResp& __y) { + return __y < __x; + } + friend bool operator<=(const ListGroupsResp& __x, const ListGroupsResp& __y) { + return !(__y < __x); + } + friend bool operator>=(const ListGroupsResp& __x, const ListGroupsResp& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() const& { + return {this->code, __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() const&& { + return {std::move(this->code), __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() & { + return {this->code, __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() && { + return {std::move(this->code), __isset.code}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() const& { + return {this->leader, __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() const&& { + return {std::move(this->leader), __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() & { + return {this->leader, __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() && { + return {std::move(this->leader), __isset.leader}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::field_ref groups_ref() const& { + return {this->groups, __isset.groups}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref groups_ref() const&& { + return {std::move(this->groups), __isset.groups}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref groups_ref() & { + return {this->groups, __isset.groups}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref groups_ref() && { + return {std::move(this->groups), __isset.groups}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::ErrorCode get_code() const { + return code; + } + + ::nebula::cpp2::ErrorCode& set_code( ::nebula::cpp2::ErrorCode code_) { + code = code_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.code = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return code; + } + const nebula::HostAddr& get_leader() const&; + nebula::HostAddr get_leader() &&; + + template + nebula::HostAddr& set_leader(T_ListGroupsResp_leader_struct_setter&& leader_) { + leader = std::forward(leader_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.leader = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return leader; + } + const ::std::vector< ::nebula::meta::cpp2::Group>& get_groups() const&; + ::std::vector< ::nebula::meta::cpp2::Group> get_groups() &&; + + template > + ::std::vector< ::nebula::meta::cpp2::Group>& set_groups(T_ListGroupsResp_groups_struct_setter&& groups_) { + groups = std::forward(groups_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.groups = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return groups; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< ListGroupsResp >; + friend void swap(ListGroupsResp& a, ListGroupsResp& b); +}; + +template +uint32_t ListGroupsResp::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class AddListenerReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = AddListenerReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + AddListenerReq() : + space_id(0), + type( ::nebula::meta::cpp2::ListenerType::UNKNOWN) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + AddListenerReq(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, ::nebula::meta::cpp2::ListenerType type__arg, ::std::vector hosts__arg); + + AddListenerReq(AddListenerReq&&) = default; + + AddListenerReq(const AddListenerReq&) = default; + + + AddListenerReq& operator=(AddListenerReq&&) = default; + + AddListenerReq& operator=(const AddListenerReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::GraphSpaceID space_id; + private: + ::nebula::meta::cpp2::ListenerType type; + private: + ::std::vector hosts; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool space_id; + bool type; + bool hosts; + } __isset = {}; + bool operator==(const AddListenerReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const AddListenerReq& __x, const AddListenerReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const AddListenerReq& rhs) const; +#ifndef SWIG + friend bool operator>(const AddListenerReq& __x, const AddListenerReq& __y) { + return __y < __x; + } + friend bool operator<=(const AddListenerReq& __x, const AddListenerReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const AddListenerReq& __x, const AddListenerReq& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const& { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const&& { + return {std::move(this->space_id), __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() & { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() && { + return {std::move(this->space_id), __isset.space_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref type_ref() const& { + return {this->type, __isset.type}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref type_ref() const&& { + return {std::move(this->type), __isset.type}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref type_ref() & { + return {this->type, __isset.type}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref type_ref() && { + return {std::move(this->type), __isset.type}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::field_ref hosts_ref() const& { + return {this->hosts, __isset.hosts}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref hosts_ref() const&& { + return {std::move(this->hosts), __isset.hosts}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref hosts_ref() & { + return {this->hosts, __isset.hosts}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref hosts_ref() && { + return {std::move(this->hosts), __isset.hosts}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::GraphSpaceID get_space_id() const { + return space_id; + } + + ::nebula::cpp2::GraphSpaceID& set_space_id( ::nebula::cpp2::GraphSpaceID space_id_) { + space_id = space_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.space_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return space_id; + } + + ::nebula::meta::cpp2::ListenerType get_type() const { + return type; + } + + ::nebula::meta::cpp2::ListenerType& set_type( ::nebula::meta::cpp2::ListenerType type_) { + type = type_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.type = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return type; + } + const ::std::vector& get_hosts() const&; + ::std::vector get_hosts() &&; + + template > + ::std::vector& set_hosts(T_AddListenerReq_hosts_struct_setter&& hosts_) { + hosts = std::forward(hosts_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.hosts = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return hosts; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< AddListenerReq >; + friend void swap(AddListenerReq& a, AddListenerReq& b); +}; + +template +uint32_t AddListenerReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class RemoveListenerReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = RemoveListenerReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + RemoveListenerReq() : + space_id(0), + type( ::nebula::meta::cpp2::ListenerType::UNKNOWN) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + RemoveListenerReq(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, ::nebula::meta::cpp2::ListenerType type__arg); + + RemoveListenerReq(RemoveListenerReq&&) = default; + + RemoveListenerReq(const RemoveListenerReq&) = default; + + + RemoveListenerReq& operator=(RemoveListenerReq&&) = default; + + RemoveListenerReq& operator=(const RemoveListenerReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::GraphSpaceID space_id; + private: + ::nebula::meta::cpp2::ListenerType type; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool space_id; + bool type; + } __isset = {}; + bool operator==(const RemoveListenerReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const RemoveListenerReq& __x, const RemoveListenerReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const RemoveListenerReq& rhs) const; +#ifndef SWIG + friend bool operator>(const RemoveListenerReq& __x, const RemoveListenerReq& __y) { + return __y < __x; + } + friend bool operator<=(const RemoveListenerReq& __x, const RemoveListenerReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const RemoveListenerReq& __x, const RemoveListenerReq& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const& { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const&& { + return {std::move(this->space_id), __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() & { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() && { + return {std::move(this->space_id), __isset.space_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref type_ref() const& { + return {this->type, __isset.type}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref type_ref() const&& { + return {std::move(this->type), __isset.type}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref type_ref() & { + return {this->type, __isset.type}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref type_ref() && { + return {std::move(this->type), __isset.type}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::GraphSpaceID get_space_id() const { + return space_id; + } + + ::nebula::cpp2::GraphSpaceID& set_space_id( ::nebula::cpp2::GraphSpaceID space_id_) { + space_id = space_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.space_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return space_id; + } + + ::nebula::meta::cpp2::ListenerType get_type() const { + return type; + } + + ::nebula::meta::cpp2::ListenerType& set_type( ::nebula::meta::cpp2::ListenerType type_) { + type = type_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.type = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return type; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< RemoveListenerReq >; + friend void swap(RemoveListenerReq& a, RemoveListenerReq& b); +}; + +template +uint32_t RemoveListenerReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class ListListenerReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = ListListenerReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + ListListenerReq() : + space_id(0) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + ListListenerReq(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg); + + ListListenerReq(ListListenerReq&&) = default; + + ListListenerReq(const ListListenerReq&) = default; + + + ListListenerReq& operator=(ListListenerReq&&) = default; + + ListListenerReq& operator=(const ListListenerReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::GraphSpaceID space_id; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool space_id; + } __isset = {}; + bool operator==(const ListListenerReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const ListListenerReq& __x, const ListListenerReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const ListListenerReq& rhs) const; +#ifndef SWIG + friend bool operator>(const ListListenerReq& __x, const ListListenerReq& __y) { + return __y < __x; + } + friend bool operator<=(const ListListenerReq& __x, const ListListenerReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const ListListenerReq& __x, const ListListenerReq& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const& { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const&& { + return {std::move(this->space_id), __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() & { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() && { + return {std::move(this->space_id), __isset.space_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::GraphSpaceID get_space_id() const { + return space_id; + } + + ::nebula::cpp2::GraphSpaceID& set_space_id( ::nebula::cpp2::GraphSpaceID space_id_) { + space_id = space_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.space_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return space_id; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< ListListenerReq >; + friend void swap(ListListenerReq& a, ListListenerReq& b); +}; + +template +uint32_t ListListenerReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class ListenerInfo final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = ListenerInfo; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + ListenerInfo() : + type( ::nebula::meta::cpp2::ListenerType::UNKNOWN), + part_id(0), + status( ::nebula::meta::cpp2::HostStatus::ONLINE) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + ListenerInfo(apache::thrift::FragileConstructor, ::nebula::meta::cpp2::ListenerType type__arg, nebula::HostAddr host__arg, ::nebula::cpp2::PartitionID part_id__arg, ::nebula::meta::cpp2::HostStatus status__arg); + + ListenerInfo(ListenerInfo&&) = default; + + ListenerInfo(const ListenerInfo&) = default; + + + ListenerInfo& operator=(ListenerInfo&&) = default; + + ListenerInfo& operator=(const ListenerInfo&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::meta::cpp2::ListenerType type; + private: + nebula::HostAddr host; + private: + ::nebula::cpp2::PartitionID part_id; + private: + ::nebula::meta::cpp2::HostStatus status; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool type; + bool host; + bool part_id; + bool status; + } __isset = {}; + bool operator==(const ListenerInfo& rhs) const; +#ifndef SWIG + friend bool operator!=(const ListenerInfo& __x, const ListenerInfo& __y) { + return !(__x == __y); + } +#endif + bool operator<(const ListenerInfo& rhs) const; +#ifndef SWIG + friend bool operator>(const ListenerInfo& __x, const ListenerInfo& __y) { + return __y < __x; + } + friend bool operator<=(const ListenerInfo& __x, const ListenerInfo& __y) { + return !(__y < __x); + } + friend bool operator>=(const ListenerInfo& __x, const ListenerInfo& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref type_ref() const& { + return {this->type, __isset.type}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref type_ref() const&& { + return {std::move(this->type), __isset.type}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref type_ref() & { + return {this->type, __isset.type}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref type_ref() && { + return {std::move(this->type), __isset.type}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref host_ref() const& { + return {this->host, __isset.host}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref host_ref() const&& { + return {std::move(this->host), __isset.host}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref host_ref() & { + return {this->host, __isset.host}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref host_ref() && { + return {std::move(this->host), __isset.host}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref part_id_ref() const& { + return {this->part_id, __isset.part_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref part_id_ref() const&& { + return {std::move(this->part_id), __isset.part_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref part_id_ref() & { + return {this->part_id, __isset.part_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref part_id_ref() && { + return {std::move(this->part_id), __isset.part_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref status_ref() const& { + return {this->status, __isset.status}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref status_ref() const&& { + return {std::move(this->status), __isset.status}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref status_ref() & { + return {this->status, __isset.status}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref status_ref() && { + return {std::move(this->status), __isset.status}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::meta::cpp2::ListenerType get_type() const { + return type; + } + + ::nebula::meta::cpp2::ListenerType& set_type( ::nebula::meta::cpp2::ListenerType type_) { + type = type_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.type = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return type; + } + const nebula::HostAddr& get_host() const&; + nebula::HostAddr get_host() &&; + + template + nebula::HostAddr& set_host(T_ListenerInfo_host_struct_setter&& host_) { + host = std::forward(host_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.host = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return host; + } + + ::nebula::cpp2::PartitionID get_part_id() const { + return part_id; + } + + ::nebula::cpp2::PartitionID& set_part_id( ::nebula::cpp2::PartitionID part_id_) { + part_id = part_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.part_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return part_id; + } + + ::nebula::meta::cpp2::HostStatus get_status() const { + return status; + } + + ::nebula::meta::cpp2::HostStatus& set_status( ::nebula::meta::cpp2::HostStatus status_) { + status = status_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.status = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return status; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< ListenerInfo >; + friend void swap(ListenerInfo& a, ListenerInfo& b); +}; + +template +uint32_t ListenerInfo::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class ListListenerResp final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = ListListenerResp; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + ListListenerResp() : + code( ::nebula::cpp2::ErrorCode::SUCCEEDED) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + ListListenerResp(apache::thrift::FragileConstructor, ::nebula::cpp2::ErrorCode code__arg, nebula::HostAddr leader__arg, ::std::vector< ::nebula::meta::cpp2::ListenerInfo> listeners__arg); + + ListListenerResp(ListListenerResp&&) = default; + + ListListenerResp(const ListListenerResp&) = default; + + + ListListenerResp& operator=(ListListenerResp&&) = default; + + ListListenerResp& operator=(const ListListenerResp&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::ErrorCode code; + private: + nebula::HostAddr leader; + private: + ::std::vector< ::nebula::meta::cpp2::ListenerInfo> listeners; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool code; + bool leader; + bool listeners; + } __isset = {}; + bool operator==(const ListListenerResp& rhs) const; +#ifndef SWIG + friend bool operator!=(const ListListenerResp& __x, const ListListenerResp& __y) { + return !(__x == __y); + } +#endif + bool operator<(const ListListenerResp& rhs) const; +#ifndef SWIG + friend bool operator>(const ListListenerResp& __x, const ListListenerResp& __y) { + return __y < __x; + } + friend bool operator<=(const ListListenerResp& __x, const ListListenerResp& __y) { + return !(__y < __x); + } + friend bool operator>=(const ListListenerResp& __x, const ListListenerResp& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() const& { + return {this->code, __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() const&& { + return {std::move(this->code), __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() & { + return {this->code, __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() && { + return {std::move(this->code), __isset.code}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() const& { + return {this->leader, __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() const&& { + return {std::move(this->leader), __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() & { + return {this->leader, __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() && { + return {std::move(this->leader), __isset.leader}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::field_ref listeners_ref() const& { + return {this->listeners, __isset.listeners}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref listeners_ref() const&& { + return {std::move(this->listeners), __isset.listeners}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref listeners_ref() & { + return {this->listeners, __isset.listeners}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref listeners_ref() && { + return {std::move(this->listeners), __isset.listeners}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::ErrorCode get_code() const { + return code; + } + + ::nebula::cpp2::ErrorCode& set_code( ::nebula::cpp2::ErrorCode code_) { + code = code_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.code = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return code; + } + const nebula::HostAddr& get_leader() const&; + nebula::HostAddr get_leader() &&; + + template + nebula::HostAddr& set_leader(T_ListListenerResp_leader_struct_setter&& leader_) { + leader = std::forward(leader_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.leader = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return leader; + } + const ::std::vector< ::nebula::meta::cpp2::ListenerInfo>& get_listeners() const&; + ::std::vector< ::nebula::meta::cpp2::ListenerInfo> get_listeners() &&; + + template > + ::std::vector< ::nebula::meta::cpp2::ListenerInfo>& set_listeners(T_ListListenerResp_listeners_struct_setter&& listeners_) { + listeners = std::forward(listeners_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.listeners = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return listeners; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< ListListenerResp >; + friend void swap(ListListenerResp& a, ListListenerResp& b); +}; + +template +uint32_t ListListenerResp::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class GetStatsReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = GetStatsReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + GetStatsReq() : + space_id(0) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + GetStatsReq(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg); + + GetStatsReq(GetStatsReq&&) = default; + + GetStatsReq(const GetStatsReq&) = default; + + + GetStatsReq& operator=(GetStatsReq&&) = default; + + GetStatsReq& operator=(const GetStatsReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::GraphSpaceID space_id; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool space_id; + } __isset = {}; + bool operator==(const GetStatsReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const GetStatsReq& __x, const GetStatsReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const GetStatsReq& rhs) const; +#ifndef SWIG + friend bool operator>(const GetStatsReq& __x, const GetStatsReq& __y) { + return __y < __x; + } + friend bool operator<=(const GetStatsReq& __x, const GetStatsReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const GetStatsReq& __x, const GetStatsReq& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const& { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const&& { + return {std::move(this->space_id), __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() & { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() && { + return {std::move(this->space_id), __isset.space_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::GraphSpaceID get_space_id() const { + return space_id; + } + + ::nebula::cpp2::GraphSpaceID& set_space_id( ::nebula::cpp2::GraphSpaceID space_id_) { + space_id = space_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.space_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return space_id; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< GetStatsReq >; + friend void swap(GetStatsReq& a, GetStatsReq& b); +}; + +template +uint32_t GetStatsReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class GetStatsResp final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = GetStatsResp; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + GetStatsResp() : + code( ::nebula::cpp2::ErrorCode::SUCCEEDED) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + GetStatsResp(apache::thrift::FragileConstructor, ::nebula::cpp2::ErrorCode code__arg, nebula::HostAddr leader__arg, ::nebula::meta::cpp2::StatsItem stats__arg); + + GetStatsResp(GetStatsResp&&) = default; + + GetStatsResp(const GetStatsResp&) = default; + + + GetStatsResp& operator=(GetStatsResp&&) = default; + + GetStatsResp& operator=(const GetStatsResp&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::ErrorCode code; + private: + nebula::HostAddr leader; + private: + ::nebula::meta::cpp2::StatsItem stats; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool code; + bool leader; + bool stats; + } __isset = {}; + bool operator==(const GetStatsResp& rhs) const; +#ifndef SWIG + friend bool operator!=(const GetStatsResp& __x, const GetStatsResp& __y) { + return !(__x == __y); + } +#endif + bool operator<(const GetStatsResp& rhs) const; +#ifndef SWIG + friend bool operator>(const GetStatsResp& __x, const GetStatsResp& __y) { + return __y < __x; + } + friend bool operator<=(const GetStatsResp& __x, const GetStatsResp& __y) { + return !(__y < __x); + } + friend bool operator>=(const GetStatsResp& __x, const GetStatsResp& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() const& { + return {this->code, __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() const&& { + return {std::move(this->code), __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() & { + return {this->code, __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() && { + return {std::move(this->code), __isset.code}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() const& { + return {this->leader, __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() const&& { + return {std::move(this->leader), __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() & { + return {this->leader, __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() && { + return {std::move(this->leader), __isset.leader}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref stats_ref() const& { + return {this->stats, __isset.stats}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref stats_ref() const&& { + return {std::move(this->stats), __isset.stats}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref stats_ref() & { + return {this->stats, __isset.stats}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref stats_ref() && { + return {std::move(this->stats), __isset.stats}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::ErrorCode get_code() const { + return code; + } + + ::nebula::cpp2::ErrorCode& set_code( ::nebula::cpp2::ErrorCode code_) { + code = code_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.code = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return code; + } + const nebula::HostAddr& get_leader() const&; + nebula::HostAddr get_leader() &&; + + template + nebula::HostAddr& set_leader(T_GetStatsResp_leader_struct_setter&& leader_) { + leader = std::forward(leader_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.leader = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return leader; + } + const ::nebula::meta::cpp2::StatsItem& get_stats() const&; + ::nebula::meta::cpp2::StatsItem get_stats() &&; + + template + ::nebula::meta::cpp2::StatsItem& set_stats(T_GetStatsResp_stats_struct_setter&& stats_) { + stats = std::forward(stats_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.stats = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return stats; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< GetStatsResp >; + friend void swap(GetStatsResp& a, GetStatsResp& b); +}; + +template +uint32_t GetStatsResp::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class BackupInfo final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = BackupInfo; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + BackupInfo() {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + BackupInfo(apache::thrift::FragileConstructor, nebula::HostAddr host__arg, ::std::vector< ::nebula::cpp2::CheckpointInfo> info__arg); + + BackupInfo(BackupInfo&&) = default; + + BackupInfo(const BackupInfo&) = default; + + + BackupInfo& operator=(BackupInfo&&) = default; + + BackupInfo& operator=(const BackupInfo&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + nebula::HostAddr host; + private: + ::std::vector< ::nebula::cpp2::CheckpointInfo> info; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool host; + bool info; + } __isset = {}; + bool operator==(const BackupInfo& rhs) const; +#ifndef SWIG + friend bool operator!=(const BackupInfo& __x, const BackupInfo& __y) { + return !(__x == __y); + } +#endif + bool operator<(const BackupInfo& rhs) const; +#ifndef SWIG + friend bool operator>(const BackupInfo& __x, const BackupInfo& __y) { + return __y < __x; + } + friend bool operator<=(const BackupInfo& __x, const BackupInfo& __y) { + return !(__y < __x); + } + friend bool operator>=(const BackupInfo& __x, const BackupInfo& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref host_ref() const& { + return {this->host, __isset.host}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref host_ref() const&& { + return {std::move(this->host), __isset.host}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref host_ref() & { + return {this->host, __isset.host}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref host_ref() && { + return {std::move(this->host), __isset.host}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::field_ref info_ref() const& { + return {this->info, __isset.info}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref info_ref() const&& { + return {std::move(this->info), __isset.info}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref info_ref() & { + return {this->info, __isset.info}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref info_ref() && { + return {std::move(this->info), __isset.info}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + const nebula::HostAddr& get_host() const&; + nebula::HostAddr get_host() &&; + + template + nebula::HostAddr& set_host(T_BackupInfo_host_struct_setter&& host_) { + host = std::forward(host_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.host = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return host; + } + const ::std::vector< ::nebula::cpp2::CheckpointInfo>& get_info() const&; + ::std::vector< ::nebula::cpp2::CheckpointInfo> get_info() &&; + + template > + ::std::vector< ::nebula::cpp2::CheckpointInfo>& set_info(T_BackupInfo_info_struct_setter&& info_) { + info = std::forward(info_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.info = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return info; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< BackupInfo >; + friend void swap(BackupInfo& a, BackupInfo& b); +}; + +template +uint32_t BackupInfo::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class SpaceBackupInfo final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = SpaceBackupInfo; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + SpaceBackupInfo() {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + SpaceBackupInfo(apache::thrift::FragileConstructor, ::nebula::meta::cpp2::SpaceDesc space__arg, ::std::vector< ::nebula::meta::cpp2::BackupInfo> info__arg); + + SpaceBackupInfo(SpaceBackupInfo&&) = default; + + SpaceBackupInfo(const SpaceBackupInfo&) = default; + + + SpaceBackupInfo& operator=(SpaceBackupInfo&&) = default; + + SpaceBackupInfo& operator=(const SpaceBackupInfo&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::meta::cpp2::SpaceDesc space; + private: + ::std::vector< ::nebula::meta::cpp2::BackupInfo> info; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool space; + bool info; + } __isset = {}; + bool operator==(const SpaceBackupInfo& rhs) const; +#ifndef SWIG + friend bool operator!=(const SpaceBackupInfo& __x, const SpaceBackupInfo& __y) { + return !(__x == __y); + } +#endif + bool operator<(const SpaceBackupInfo& rhs) const; +#ifndef SWIG + friend bool operator>(const SpaceBackupInfo& __x, const SpaceBackupInfo& __y) { + return __y < __x; + } + friend bool operator<=(const SpaceBackupInfo& __x, const SpaceBackupInfo& __y) { + return !(__y < __x); + } + friend bool operator>=(const SpaceBackupInfo& __x, const SpaceBackupInfo& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref space_ref() const& { + return {this->space, __isset.space}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_ref() const&& { + return {std::move(this->space), __isset.space}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_ref() & { + return {this->space, __isset.space}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_ref() && { + return {std::move(this->space), __isset.space}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::field_ref info_ref() const& { + return {this->info, __isset.info}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref info_ref() const&& { + return {std::move(this->info), __isset.info}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref info_ref() & { + return {this->info, __isset.info}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref info_ref() && { + return {std::move(this->info), __isset.info}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + const ::nebula::meta::cpp2::SpaceDesc& get_space() const&; + ::nebula::meta::cpp2::SpaceDesc get_space() &&; + + template + ::nebula::meta::cpp2::SpaceDesc& set_space(T_SpaceBackupInfo_space_struct_setter&& space_) { + space = std::forward(space_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.space = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return space; + } + const ::std::vector< ::nebula::meta::cpp2::BackupInfo>& get_info() const&; + ::std::vector< ::nebula::meta::cpp2::BackupInfo> get_info() &&; + + template > + ::std::vector< ::nebula::meta::cpp2::BackupInfo>& set_info(T_SpaceBackupInfo_info_struct_setter&& info_) { + info = std::forward(info_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.info = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return info; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< SpaceBackupInfo >; + friend void swap(SpaceBackupInfo& a, SpaceBackupInfo& b); +}; + +template +uint32_t SpaceBackupInfo::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class BackupMeta final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = BackupMeta; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + + BackupMeta(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + BackupMeta(apache::thrift::FragileConstructor, std::unordered_map< ::nebula::cpp2::GraphSpaceID, ::nebula::meta::cpp2::SpaceBackupInfo> backup_info__arg, ::std::vector<::std::string> meta_files__arg, ::std::string backup_name__arg, bool full__arg, bool include_system_space__arg, int64_t create_time__arg); + + BackupMeta(BackupMeta&&) = default; + + BackupMeta(const BackupMeta&) = default; + + + BackupMeta& operator=(BackupMeta&&) = default; + + BackupMeta& operator=(const BackupMeta&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + + ~BackupMeta(); + + private: + std::unordered_map< ::nebula::cpp2::GraphSpaceID, ::nebula::meta::cpp2::SpaceBackupInfo> backup_info; + private: + ::std::vector<::std::string> meta_files; + private: + ::std::string backup_name; + private: + bool full; + private: + bool include_system_space; + private: + int64_t create_time; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool backup_info; + bool meta_files; + bool backup_name; + bool full; + bool include_system_space; + bool create_time; + } __isset = {}; + bool operator==(const BackupMeta& rhs) const; +#ifndef SWIG + friend bool operator!=(const BackupMeta& __x, const BackupMeta& __y) { + return !(__x == __y); + } +#endif + bool operator<(const BackupMeta& rhs) const; +#ifndef SWIG + friend bool operator>(const BackupMeta& __x, const BackupMeta& __y) { + return __y < __x; + } + friend bool operator<=(const BackupMeta& __x, const BackupMeta& __y) { + return !(__y < __x); + } + friend bool operator>=(const BackupMeta& __x, const BackupMeta& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::field_ref backup_info_ref() const& { + return {this->backup_info, __isset.backup_info}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref backup_info_ref() const&& { + return {std::move(this->backup_info), __isset.backup_info}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref backup_info_ref() & { + return {this->backup_info, __isset.backup_info}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref backup_info_ref() && { + return {std::move(this->backup_info), __isset.backup_info}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::field_ref meta_files_ref() const& { + return {this->meta_files, __isset.meta_files}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref meta_files_ref() const&& { + return {std::move(this->meta_files), __isset.meta_files}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref meta_files_ref() & { + return {this->meta_files, __isset.meta_files}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref meta_files_ref() && { + return {std::move(this->meta_files), __isset.meta_files}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref backup_name_ref() const& { + return {this->backup_name, __isset.backup_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref backup_name_ref() const&& { + return {std::move(this->backup_name), __isset.backup_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref backup_name_ref() & { + return {this->backup_name, __isset.backup_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref backup_name_ref() && { + return {std::move(this->backup_name), __isset.backup_name}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref full_ref() const& { + return {this->full, __isset.full}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref full_ref() const&& { + return {std::move(this->full), __isset.full}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref full_ref() & { + return {this->full, __isset.full}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref full_ref() && { + return {std::move(this->full), __isset.full}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref include_system_space_ref() const& { + return {this->include_system_space, __isset.include_system_space}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref include_system_space_ref() const&& { + return {std::move(this->include_system_space), __isset.include_system_space}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref include_system_space_ref() & { + return {this->include_system_space, __isset.include_system_space}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref include_system_space_ref() && { + return {std::move(this->include_system_space), __isset.include_system_space}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref create_time_ref() const& { + return {this->create_time, __isset.create_time}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref create_time_ref() const&& { + return {std::move(this->create_time), __isset.create_time}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref create_time_ref() & { + return {this->create_time, __isset.create_time}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref create_time_ref() && { + return {std::move(this->create_time), __isset.create_time}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + const std::unordered_map< ::nebula::cpp2::GraphSpaceID, ::nebula::meta::cpp2::SpaceBackupInfo>& get_backup_info() const&; + std::unordered_map< ::nebula::cpp2::GraphSpaceID, ::nebula::meta::cpp2::SpaceBackupInfo> get_backup_info() &&; + + template > + std::unordered_map< ::nebula::cpp2::GraphSpaceID, ::nebula::meta::cpp2::SpaceBackupInfo>& set_backup_info(T_BackupMeta_backup_info_struct_setter&& backup_info_) { + backup_info = std::forward(backup_info_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.backup_info = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return backup_info; + } + const ::std::vector<::std::string>& get_meta_files() const&; + ::std::vector<::std::string> get_meta_files() &&; + + template > + ::std::vector<::std::string>& set_meta_files(T_BackupMeta_meta_files_struct_setter&& meta_files_) { + meta_files = std::forward(meta_files_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.meta_files = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return meta_files; + } + + const ::std::string& get_backup_name() const& { + return backup_name; + } + + ::std::string get_backup_name() && { + return std::move(backup_name); + } + + template + ::std::string& set_backup_name(T_BackupMeta_backup_name_struct_setter&& backup_name_) { + backup_name = std::forward(backup_name_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.backup_name = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return backup_name; + } + + bool get_full() const { + return full; + } + + bool& set_full(bool full_) { + full = full_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.full = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return full; + } + + bool get_include_system_space() const { + return include_system_space; + } + + bool& set_include_system_space(bool include_system_space_) { + include_system_space = include_system_space_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.include_system_space = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return include_system_space; + } + + int64_t get_create_time() const { + return create_time; + } + + int64_t& set_create_time(int64_t create_time_) { + create_time = create_time_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.create_time = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return create_time; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< BackupMeta >; + friend void swap(BackupMeta& a, BackupMeta& b); +}; + +template +uint32_t BackupMeta::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class CreateBackupReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = CreateBackupReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + CreateBackupReq() {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + CreateBackupReq(apache::thrift::FragileConstructor, ::std::vector<::std::string> spaces__arg); + + CreateBackupReq(CreateBackupReq&&) = default; + + CreateBackupReq(const CreateBackupReq&) = default; + + + CreateBackupReq& operator=(CreateBackupReq&&) = default; + + CreateBackupReq& operator=(const CreateBackupReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::std::vector<::std::string> spaces; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool spaces; + } __isset = {}; + bool operator==(const CreateBackupReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const CreateBackupReq& __x, const CreateBackupReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const CreateBackupReq& rhs) const; +#ifndef SWIG + friend bool operator>(const CreateBackupReq& __x, const CreateBackupReq& __y) { + return __y < __x; + } + friend bool operator<=(const CreateBackupReq& __x, const CreateBackupReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const CreateBackupReq& __x, const CreateBackupReq& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::optional_field_ref spaces_ref() const& { + return {this->spaces, __isset.spaces}; + } + + template > + FOLLY_ERASE ::apache::thrift::optional_field_ref spaces_ref() const&& { + return {std::move(this->spaces), __isset.spaces}; + } + + template > + FOLLY_ERASE ::apache::thrift::optional_field_ref spaces_ref() & { + return {this->spaces, __isset.spaces}; + } + + template > + FOLLY_ERASE ::apache::thrift::optional_field_ref spaces_ref() && { + return {std::move(this->spaces), __isset.spaces}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + const ::std::vector<::std::string>* get_spaces() const&; + ::std::vector<::std::string>* get_spaces() &; + ::std::vector<::std::string>* get_spaces() && = delete; + + template > + ::std::vector<::std::string>& set_spaces(T_CreateBackupReq_spaces_struct_setter&& spaces_) { + spaces = std::forward(spaces_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.spaces = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return spaces; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< CreateBackupReq >; + friend void swap(CreateBackupReq& a, CreateBackupReq& b); +}; + +template +uint32_t CreateBackupReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class CreateBackupResp final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = CreateBackupResp; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + CreateBackupResp() : + code( ::nebula::cpp2::ErrorCode::SUCCEEDED) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + CreateBackupResp(apache::thrift::FragileConstructor, ::nebula::cpp2::ErrorCode code__arg, nebula::HostAddr leader__arg, ::nebula::meta::cpp2::BackupMeta meta__arg); + + CreateBackupResp(CreateBackupResp&&) = default; + + CreateBackupResp(const CreateBackupResp&) = default; + + + CreateBackupResp& operator=(CreateBackupResp&&) = default; + + CreateBackupResp& operator=(const CreateBackupResp&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::ErrorCode code; + private: + nebula::HostAddr leader; + private: + ::nebula::meta::cpp2::BackupMeta meta; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool code; + bool leader; + bool meta; + } __isset = {}; + bool operator==(const CreateBackupResp& rhs) const; +#ifndef SWIG + friend bool operator!=(const CreateBackupResp& __x, const CreateBackupResp& __y) { + return !(__x == __y); + } +#endif + bool operator<(const CreateBackupResp& rhs) const; +#ifndef SWIG + friend bool operator>(const CreateBackupResp& __x, const CreateBackupResp& __y) { + return __y < __x; + } + friend bool operator<=(const CreateBackupResp& __x, const CreateBackupResp& __y) { + return !(__y < __x); + } + friend bool operator>=(const CreateBackupResp& __x, const CreateBackupResp& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() const& { + return {this->code, __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() const&& { + return {std::move(this->code), __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() & { + return {this->code, __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() && { + return {std::move(this->code), __isset.code}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() const& { + return {this->leader, __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() const&& { + return {std::move(this->leader), __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() & { + return {this->leader, __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() && { + return {std::move(this->leader), __isset.leader}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref meta_ref() const& { + return {this->meta, __isset.meta}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref meta_ref() const&& { + return {std::move(this->meta), __isset.meta}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref meta_ref() & { + return {this->meta, __isset.meta}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref meta_ref() && { + return {std::move(this->meta), __isset.meta}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::ErrorCode get_code() const { + return code; + } + + ::nebula::cpp2::ErrorCode& set_code( ::nebula::cpp2::ErrorCode code_) { + code = code_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.code = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return code; + } + const nebula::HostAddr& get_leader() const&; + nebula::HostAddr get_leader() &&; + + template + nebula::HostAddr& set_leader(T_CreateBackupResp_leader_struct_setter&& leader_) { + leader = std::forward(leader_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.leader = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return leader; + } + const ::nebula::meta::cpp2::BackupMeta& get_meta() const&; + ::nebula::meta::cpp2::BackupMeta get_meta() &&; + + template + ::nebula::meta::cpp2::BackupMeta& set_meta(T_CreateBackupResp_meta_struct_setter&& meta_) { + meta = std::forward(meta_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.meta = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return meta; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< CreateBackupResp >; + friend void swap(CreateBackupResp& a, CreateBackupResp& b); +}; + +template +uint32_t CreateBackupResp::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class HostPair final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = HostPair; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + HostPair() {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + HostPair(apache::thrift::FragileConstructor, nebula::HostAddr from_host__arg, nebula::HostAddr to_host__arg); + + HostPair(HostPair&&) = default; + + HostPair(const HostPair&) = default; + + + HostPair& operator=(HostPair&&) = default; + + HostPair& operator=(const HostPair&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + nebula::HostAddr from_host; + private: + nebula::HostAddr to_host; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool from_host; + bool to_host; + } __isset = {}; + bool operator==(const HostPair& rhs) const; +#ifndef SWIG + friend bool operator!=(const HostPair& __x, const HostPair& __y) { + return !(__x == __y); + } +#endif + bool operator<(const HostPair& rhs) const; +#ifndef SWIG + friend bool operator>(const HostPair& __x, const HostPair& __y) { + return __y < __x; + } + friend bool operator<=(const HostPair& __x, const HostPair& __y) { + return !(__y < __x); + } + friend bool operator>=(const HostPair& __x, const HostPair& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref from_host_ref() const& { + return {this->from_host, __isset.from_host}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref from_host_ref() const&& { + return {std::move(this->from_host), __isset.from_host}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref from_host_ref() & { + return {this->from_host, __isset.from_host}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref from_host_ref() && { + return {std::move(this->from_host), __isset.from_host}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref to_host_ref() const& { + return {this->to_host, __isset.to_host}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref to_host_ref() const&& { + return {std::move(this->to_host), __isset.to_host}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref to_host_ref() & { + return {this->to_host, __isset.to_host}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref to_host_ref() && { + return {std::move(this->to_host), __isset.to_host}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + const nebula::HostAddr& get_from_host() const&; + nebula::HostAddr get_from_host() &&; + + template + nebula::HostAddr& set_from_host(T_HostPair_from_host_struct_setter&& from_host_) { + from_host = std::forward(from_host_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.from_host = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return from_host; + } + const nebula::HostAddr& get_to_host() const&; + nebula::HostAddr get_to_host() &&; + + template + nebula::HostAddr& set_to_host(T_HostPair_to_host_struct_setter&& to_host_) { + to_host = std::forward(to_host_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.to_host = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return to_host; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< HostPair >; + friend void swap(HostPair& a, HostPair& b); +}; + +template +uint32_t HostPair::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class RestoreMetaReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = RestoreMetaReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + RestoreMetaReq() {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + RestoreMetaReq(apache::thrift::FragileConstructor, ::std::vector<::std::string> files__arg, ::std::vector< ::nebula::meta::cpp2::HostPair> hosts__arg); + + RestoreMetaReq(RestoreMetaReq&&) = default; + + RestoreMetaReq(const RestoreMetaReq&) = default; + + + RestoreMetaReq& operator=(RestoreMetaReq&&) = default; + + RestoreMetaReq& operator=(const RestoreMetaReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::std::vector<::std::string> files; + private: + ::std::vector< ::nebula::meta::cpp2::HostPair> hosts; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool files; + bool hosts; + } __isset = {}; + bool operator==(const RestoreMetaReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const RestoreMetaReq& __x, const RestoreMetaReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const RestoreMetaReq& rhs) const; +#ifndef SWIG + friend bool operator>(const RestoreMetaReq& __x, const RestoreMetaReq& __y) { + return __y < __x; + } + friend bool operator<=(const RestoreMetaReq& __x, const RestoreMetaReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const RestoreMetaReq& __x, const RestoreMetaReq& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::field_ref files_ref() const& { + return {this->files, __isset.files}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref files_ref() const&& { + return {std::move(this->files), __isset.files}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref files_ref() & { + return {this->files, __isset.files}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref files_ref() && { + return {std::move(this->files), __isset.files}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::field_ref hosts_ref() const& { + return {this->hosts, __isset.hosts}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref hosts_ref() const&& { + return {std::move(this->hosts), __isset.hosts}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref hosts_ref() & { + return {this->hosts, __isset.hosts}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref hosts_ref() && { + return {std::move(this->hosts), __isset.hosts}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + const ::std::vector<::std::string>& get_files() const&; + ::std::vector<::std::string> get_files() &&; + + template > + ::std::vector<::std::string>& set_files(T_RestoreMetaReq_files_struct_setter&& files_) { + files = std::forward(files_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.files = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return files; + } + const ::std::vector< ::nebula::meta::cpp2::HostPair>& get_hosts() const&; + ::std::vector< ::nebula::meta::cpp2::HostPair> get_hosts() &&; + + template > + ::std::vector< ::nebula::meta::cpp2::HostPair>& set_hosts(T_RestoreMetaReq_hosts_struct_setter&& hosts_) { + hosts = std::forward(hosts_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.hosts = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return hosts; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< RestoreMetaReq >; + friend void swap(RestoreMetaReq& a, RestoreMetaReq& b); +}; + +template +uint32_t RestoreMetaReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class FTClient final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = FTClient; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + FTClient() {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + FTClient(apache::thrift::FragileConstructor, nebula::HostAddr host__arg, ::std::string user__arg, ::std::string pwd__arg); + + FTClient(FTClient&&) = default; + + FTClient(const FTClient&) = default; + + + FTClient& operator=(FTClient&&) = default; + + FTClient& operator=(const FTClient&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + public: + nebula::HostAddr host; + private: + ::std::string user; + private: + ::std::string pwd; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool user; + bool pwd; + } __isset = {}; + bool operator==(const FTClient& rhs) const; +#ifndef SWIG + friend bool operator!=(const FTClient& __x, const FTClient& __y) { + return !(__x == __y); + } +#endif + bool operator<(const FTClient& rhs) const; +#ifndef SWIG + friend bool operator>(const FTClient& __x, const FTClient& __y) { + return __y < __x; + } + friend bool operator<=(const FTClient& __x, const FTClient& __y) { + return !(__y < __x); + } + friend bool operator>=(const FTClient& __x, const FTClient& __y) { + return !(__x < __y); + } +#endif + template + FOLLY_ERASE ::apache::thrift::required_field_ref host_ref() const& { + return ::apache::thrift::required_field_ref{this->host}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref host_ref() const&& { + return ::apache::thrift::required_field_ref{std::move(this->host)}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref host_ref() & { + return ::apache::thrift::required_field_ref{this->host}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref host_ref() && { + return ::apache::thrift::required_field_ref{std::move(this->host)}; + } + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::optional_field_ref user_ref() const& { + return {this->user, __isset.user}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref user_ref() const&& { + return {std::move(this->user), __isset.user}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref user_ref() & { + return {this->user, __isset.user}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref user_ref() && { + return {std::move(this->user), __isset.user}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::optional_field_ref pwd_ref() const& { + return {this->pwd, __isset.pwd}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref pwd_ref() const&& { + return {std::move(this->pwd), __isset.pwd}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref pwd_ref() & { + return {this->pwd, __isset.pwd}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref pwd_ref() && { + return {std::move(this->pwd), __isset.pwd}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + const nebula::HostAddr& get_host() const&; + nebula::HostAddr get_host() &&; + + template + nebula::HostAddr& set_host(T_FTClient_host_struct_setter&& host_) { + host = std::forward(host_); + return host; + } + + const ::std::string* get_user() const& { + return user_ref() ? std::addressof(user) : nullptr; + } + + ::std::string* get_user() & { + return user_ref() ? std::addressof(user) : nullptr; + } + ::std::string* get_user() && = delete; + + template + ::std::string& set_user(T_FTClient_user_struct_setter&& user_) { + user = std::forward(user_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.user = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return user; + } + + const ::std::string* get_pwd() const& { + return pwd_ref() ? std::addressof(pwd) : nullptr; + } + + ::std::string* get_pwd() & { + return pwd_ref() ? std::addressof(pwd) : nullptr; + } + ::std::string* get_pwd() && = delete; + + template + ::std::string& set_pwd(T_FTClient_pwd_struct_setter&& pwd_) { + pwd = std::forward(pwd_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.pwd = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return pwd; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< FTClient >; + friend void swap(FTClient& a, FTClient& b); +}; + +template +uint32_t FTClient::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class SignInFTServiceReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = SignInFTServiceReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + SignInFTServiceReq() : + type(static_cast< ::nebula::meta::cpp2::FTServiceType>(0)) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + SignInFTServiceReq(apache::thrift::FragileConstructor, ::nebula::meta::cpp2::FTServiceType type__arg, ::std::vector< ::nebula::meta::cpp2::FTClient> clients__arg); + + SignInFTServiceReq(SignInFTServiceReq&&) = default; + + SignInFTServiceReq(const SignInFTServiceReq&) = default; + + + SignInFTServiceReq& operator=(SignInFTServiceReq&&) = default; + + SignInFTServiceReq& operator=(const SignInFTServiceReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::meta::cpp2::FTServiceType type; + private: + ::std::vector< ::nebula::meta::cpp2::FTClient> clients; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool type; + bool clients; + } __isset = {}; + bool operator==(const SignInFTServiceReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const SignInFTServiceReq& __x, const SignInFTServiceReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const SignInFTServiceReq& rhs) const; +#ifndef SWIG + friend bool operator>(const SignInFTServiceReq& __x, const SignInFTServiceReq& __y) { + return __y < __x; + } + friend bool operator<=(const SignInFTServiceReq& __x, const SignInFTServiceReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const SignInFTServiceReq& __x, const SignInFTServiceReq& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref type_ref() const& { + return {this->type, __isset.type}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref type_ref() const&& { + return {std::move(this->type), __isset.type}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref type_ref() & { + return {this->type, __isset.type}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref type_ref() && { + return {std::move(this->type), __isset.type}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::field_ref clients_ref() const& { + return {this->clients, __isset.clients}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref clients_ref() const&& { + return {std::move(this->clients), __isset.clients}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref clients_ref() & { + return {this->clients, __isset.clients}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref clients_ref() && { + return {std::move(this->clients), __isset.clients}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::meta::cpp2::FTServiceType get_type() const { + return type; + } + + ::nebula::meta::cpp2::FTServiceType& set_type( ::nebula::meta::cpp2::FTServiceType type_) { + type = type_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.type = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return type; + } + const ::std::vector< ::nebula::meta::cpp2::FTClient>& get_clients() const&; + ::std::vector< ::nebula::meta::cpp2::FTClient> get_clients() &&; + + template > + ::std::vector< ::nebula::meta::cpp2::FTClient>& set_clients(T_SignInFTServiceReq_clients_struct_setter&& clients_) { + clients = std::forward(clients_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.clients = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return clients; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< SignInFTServiceReq >; + friend void swap(SignInFTServiceReq& a, SignInFTServiceReq& b); +}; + +template +uint32_t SignInFTServiceReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class SignOutFTServiceReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = SignOutFTServiceReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + SignOutFTServiceReq() {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + SignOutFTServiceReq(apache::thrift::FragileConstructor); + + SignOutFTServiceReq(SignOutFTServiceReq&&) = default; + + SignOutFTServiceReq(const SignOutFTServiceReq&) = default; + + + SignOutFTServiceReq& operator=(SignOutFTServiceReq&&) = default; + + SignOutFTServiceReq& operator=(const SignOutFTServiceReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + bool operator==(const SignOutFTServiceReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const SignOutFTServiceReq& __x, const SignOutFTServiceReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const SignOutFTServiceReq& rhs) const; +#ifndef SWIG + friend bool operator>(const SignOutFTServiceReq& __x, const SignOutFTServiceReq& __y) { + return __y < __x; + } + friend bool operator<=(const SignOutFTServiceReq& __x, const SignOutFTServiceReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const SignOutFTServiceReq& __x, const SignOutFTServiceReq& __y) { + return !(__x < __y); + } +#endif + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< SignOutFTServiceReq >; + friend void swap(SignOutFTServiceReq& a, SignOutFTServiceReq& b); +}; + +template +uint32_t SignOutFTServiceReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class ListFTClientsReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = ListFTClientsReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + ListFTClientsReq() {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + ListFTClientsReq(apache::thrift::FragileConstructor); + + ListFTClientsReq(ListFTClientsReq&&) = default; + + ListFTClientsReq(const ListFTClientsReq&) = default; + + + ListFTClientsReq& operator=(ListFTClientsReq&&) = default; + + ListFTClientsReq& operator=(const ListFTClientsReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + bool operator==(const ListFTClientsReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const ListFTClientsReq& __x, const ListFTClientsReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const ListFTClientsReq& rhs) const; +#ifndef SWIG + friend bool operator>(const ListFTClientsReq& __x, const ListFTClientsReq& __y) { + return __y < __x; + } + friend bool operator<=(const ListFTClientsReq& __x, const ListFTClientsReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const ListFTClientsReq& __x, const ListFTClientsReq& __y) { + return !(__x < __y); + } +#endif + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< ListFTClientsReq >; + friend void swap(ListFTClientsReq& a, ListFTClientsReq& b); +}; + +template +uint32_t ListFTClientsReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class ListFTClientsResp final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = ListFTClientsResp; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + ListFTClientsResp() : + code( ::nebula::cpp2::ErrorCode::SUCCEEDED) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + ListFTClientsResp(apache::thrift::FragileConstructor, ::nebula::cpp2::ErrorCode code__arg, nebula::HostAddr leader__arg, ::std::vector< ::nebula::meta::cpp2::FTClient> clients__arg); + + ListFTClientsResp(ListFTClientsResp&&) = default; + + ListFTClientsResp(const ListFTClientsResp&) = default; + + + ListFTClientsResp& operator=(ListFTClientsResp&&) = default; + + ListFTClientsResp& operator=(const ListFTClientsResp&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::ErrorCode code; + private: + nebula::HostAddr leader; + private: + ::std::vector< ::nebula::meta::cpp2::FTClient> clients; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool code; + bool leader; + bool clients; + } __isset = {}; + bool operator==(const ListFTClientsResp& rhs) const; +#ifndef SWIG + friend bool operator!=(const ListFTClientsResp& __x, const ListFTClientsResp& __y) { + return !(__x == __y); + } +#endif + bool operator<(const ListFTClientsResp& rhs) const; +#ifndef SWIG + friend bool operator>(const ListFTClientsResp& __x, const ListFTClientsResp& __y) { + return __y < __x; + } + friend bool operator<=(const ListFTClientsResp& __x, const ListFTClientsResp& __y) { + return !(__y < __x); + } + friend bool operator>=(const ListFTClientsResp& __x, const ListFTClientsResp& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() const& { + return {this->code, __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() const&& { + return {std::move(this->code), __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() & { + return {this->code, __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() && { + return {std::move(this->code), __isset.code}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() const& { + return {this->leader, __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() const&& { + return {std::move(this->leader), __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() & { + return {this->leader, __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() && { + return {std::move(this->leader), __isset.leader}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::field_ref clients_ref() const& { + return {this->clients, __isset.clients}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref clients_ref() const&& { + return {std::move(this->clients), __isset.clients}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref clients_ref() & { + return {this->clients, __isset.clients}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref clients_ref() && { + return {std::move(this->clients), __isset.clients}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::ErrorCode get_code() const { + return code; + } + + ::nebula::cpp2::ErrorCode& set_code( ::nebula::cpp2::ErrorCode code_) { + code = code_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.code = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return code; + } + const nebula::HostAddr& get_leader() const&; + nebula::HostAddr get_leader() &&; + + template + nebula::HostAddr& set_leader(T_ListFTClientsResp_leader_struct_setter&& leader_) { + leader = std::forward(leader_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.leader = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return leader; + } + const ::std::vector< ::nebula::meta::cpp2::FTClient>& get_clients() const&; + ::std::vector< ::nebula::meta::cpp2::FTClient> get_clients() &&; + + template > + ::std::vector< ::nebula::meta::cpp2::FTClient>& set_clients(T_ListFTClientsResp_clients_struct_setter&& clients_) { + clients = std::forward(clients_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.clients = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return clients; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< ListFTClientsResp >; + friend void swap(ListFTClientsResp& a, ListFTClientsResp& b); +}; + +template +uint32_t ListFTClientsResp::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class FTIndex final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = FTIndex; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + FTIndex() : + space_id(0) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + FTIndex(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, ::nebula::cpp2::SchemaID depend_schema__arg, ::std::vector<::std::string> fields__arg); + + FTIndex(FTIndex&&) = default; + + FTIndex(const FTIndex&) = default; + + + FTIndex& operator=(FTIndex&&) = default; + + FTIndex& operator=(const FTIndex&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::GraphSpaceID space_id; + private: + ::nebula::cpp2::SchemaID depend_schema; + private: + ::std::vector<::std::string> fields; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool space_id; + bool depend_schema; + bool fields; + } __isset = {}; + bool operator==(const FTIndex& rhs) const; +#ifndef SWIG + friend bool operator!=(const FTIndex& __x, const FTIndex& __y) { + return !(__x == __y); + } +#endif + bool operator<(const FTIndex& rhs) const; +#ifndef SWIG + friend bool operator>(const FTIndex& __x, const FTIndex& __y) { + return __y < __x; + } + friend bool operator<=(const FTIndex& __x, const FTIndex& __y) { + return !(__y < __x); + } + friend bool operator>=(const FTIndex& __x, const FTIndex& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const& { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const&& { + return {std::move(this->space_id), __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() & { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() && { + return {std::move(this->space_id), __isset.space_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref depend_schema_ref() const& { + return {this->depend_schema, __isset.depend_schema}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref depend_schema_ref() const&& { + return {std::move(this->depend_schema), __isset.depend_schema}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref depend_schema_ref() & { + return {this->depend_schema, __isset.depend_schema}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref depend_schema_ref() && { + return {std::move(this->depend_schema), __isset.depend_schema}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::field_ref fields_ref() const& { + return {this->fields, __isset.fields}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref fields_ref() const&& { + return {std::move(this->fields), __isset.fields}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref fields_ref() & { + return {this->fields, __isset.fields}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref fields_ref() && { + return {std::move(this->fields), __isset.fields}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::GraphSpaceID get_space_id() const { + return space_id; + } + + ::nebula::cpp2::GraphSpaceID& set_space_id( ::nebula::cpp2::GraphSpaceID space_id_) { + space_id = space_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.space_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return space_id; + } + const ::nebula::cpp2::SchemaID& get_depend_schema() const&; + ::nebula::cpp2::SchemaID get_depend_schema() &&; + + template + ::nebula::cpp2::SchemaID& set_depend_schema(T_FTIndex_depend_schema_struct_setter&& depend_schema_) { + depend_schema = std::forward(depend_schema_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.depend_schema = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return depend_schema; + } + const ::std::vector<::std::string>& get_fields() const&; + ::std::vector<::std::string> get_fields() &&; + + template > + ::std::vector<::std::string>& set_fields(T_FTIndex_fields_struct_setter&& fields_) { + fields = std::forward(fields_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.fields = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return fields; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< FTIndex >; + friend void swap(FTIndex& a, FTIndex& b); +}; + +template +uint32_t FTIndex::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class CreateFTIndexReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = CreateFTIndexReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + CreateFTIndexReq() {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + CreateFTIndexReq(apache::thrift::FragileConstructor, ::std::string fulltext_index_name__arg, ::nebula::meta::cpp2::FTIndex index__arg); + + CreateFTIndexReq(CreateFTIndexReq&&) = default; + + CreateFTIndexReq(const CreateFTIndexReq&) = default; + + + CreateFTIndexReq& operator=(CreateFTIndexReq&&) = default; + + CreateFTIndexReq& operator=(const CreateFTIndexReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::std::string fulltext_index_name; + private: + ::nebula::meta::cpp2::FTIndex index; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool fulltext_index_name; + bool index; + } __isset = {}; + bool operator==(const CreateFTIndexReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const CreateFTIndexReq& __x, const CreateFTIndexReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const CreateFTIndexReq& rhs) const; +#ifndef SWIG + friend bool operator>(const CreateFTIndexReq& __x, const CreateFTIndexReq& __y) { + return __y < __x; + } + friend bool operator<=(const CreateFTIndexReq& __x, const CreateFTIndexReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const CreateFTIndexReq& __x, const CreateFTIndexReq& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref fulltext_index_name_ref() const& { + return {this->fulltext_index_name, __isset.fulltext_index_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref fulltext_index_name_ref() const&& { + return {std::move(this->fulltext_index_name), __isset.fulltext_index_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref fulltext_index_name_ref() & { + return {this->fulltext_index_name, __isset.fulltext_index_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref fulltext_index_name_ref() && { + return {std::move(this->fulltext_index_name), __isset.fulltext_index_name}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref index_ref() const& { + return {this->index, __isset.index}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref index_ref() const&& { + return {std::move(this->index), __isset.index}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref index_ref() & { + return {this->index, __isset.index}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref index_ref() && { + return {std::move(this->index), __isset.index}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + const ::std::string& get_fulltext_index_name() const& { + return fulltext_index_name; + } + + ::std::string get_fulltext_index_name() && { + return std::move(fulltext_index_name); + } + + template + ::std::string& set_fulltext_index_name(T_CreateFTIndexReq_fulltext_index_name_struct_setter&& fulltext_index_name_) { + fulltext_index_name = std::forward(fulltext_index_name_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.fulltext_index_name = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return fulltext_index_name; + } + const ::nebula::meta::cpp2::FTIndex& get_index() const&; + ::nebula::meta::cpp2::FTIndex get_index() &&; + + template + ::nebula::meta::cpp2::FTIndex& set_index(T_CreateFTIndexReq_index_struct_setter&& index_) { + index = std::forward(index_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.index = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return index; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< CreateFTIndexReq >; + friend void swap(CreateFTIndexReq& a, CreateFTIndexReq& b); +}; + +template +uint32_t CreateFTIndexReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class DropFTIndexReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = DropFTIndexReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + DropFTIndexReq() : + space_id(0) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + DropFTIndexReq(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, ::std::string fulltext_index_name__arg); + + DropFTIndexReq(DropFTIndexReq&&) = default; + + DropFTIndexReq(const DropFTIndexReq&) = default; + + + DropFTIndexReq& operator=(DropFTIndexReq&&) = default; + + DropFTIndexReq& operator=(const DropFTIndexReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::GraphSpaceID space_id; + private: + ::std::string fulltext_index_name; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool space_id; + bool fulltext_index_name; + } __isset = {}; + bool operator==(const DropFTIndexReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const DropFTIndexReq& __x, const DropFTIndexReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const DropFTIndexReq& rhs) const; +#ifndef SWIG + friend bool operator>(const DropFTIndexReq& __x, const DropFTIndexReq& __y) { + return __y < __x; + } + friend bool operator<=(const DropFTIndexReq& __x, const DropFTIndexReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const DropFTIndexReq& __x, const DropFTIndexReq& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const& { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const&& { + return {std::move(this->space_id), __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() & { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() && { + return {std::move(this->space_id), __isset.space_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref fulltext_index_name_ref() const& { + return {this->fulltext_index_name, __isset.fulltext_index_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref fulltext_index_name_ref() const&& { + return {std::move(this->fulltext_index_name), __isset.fulltext_index_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref fulltext_index_name_ref() & { + return {this->fulltext_index_name, __isset.fulltext_index_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref fulltext_index_name_ref() && { + return {std::move(this->fulltext_index_name), __isset.fulltext_index_name}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::GraphSpaceID get_space_id() const { + return space_id; + } + + ::nebula::cpp2::GraphSpaceID& set_space_id( ::nebula::cpp2::GraphSpaceID space_id_) { + space_id = space_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.space_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return space_id; + } + + const ::std::string& get_fulltext_index_name() const& { + return fulltext_index_name; + } + + ::std::string get_fulltext_index_name() && { + return std::move(fulltext_index_name); + } + + template + ::std::string& set_fulltext_index_name(T_DropFTIndexReq_fulltext_index_name_struct_setter&& fulltext_index_name_) { + fulltext_index_name = std::forward(fulltext_index_name_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.fulltext_index_name = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return fulltext_index_name; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< DropFTIndexReq >; + friend void swap(DropFTIndexReq& a, DropFTIndexReq& b); +}; + +template +uint32_t DropFTIndexReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class ListFTIndexesReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = ListFTIndexesReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + ListFTIndexesReq() {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + ListFTIndexesReq(apache::thrift::FragileConstructor); + + ListFTIndexesReq(ListFTIndexesReq&&) = default; + + ListFTIndexesReq(const ListFTIndexesReq&) = default; + + + ListFTIndexesReq& operator=(ListFTIndexesReq&&) = default; + + ListFTIndexesReq& operator=(const ListFTIndexesReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + bool operator==(const ListFTIndexesReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const ListFTIndexesReq& __x, const ListFTIndexesReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const ListFTIndexesReq& rhs) const; +#ifndef SWIG + friend bool operator>(const ListFTIndexesReq& __x, const ListFTIndexesReq& __y) { + return __y < __x; + } + friend bool operator<=(const ListFTIndexesReq& __x, const ListFTIndexesReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const ListFTIndexesReq& __x, const ListFTIndexesReq& __y) { + return !(__x < __y); + } +#endif + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< ListFTIndexesReq >; + friend void swap(ListFTIndexesReq& a, ListFTIndexesReq& b); +}; + +template +uint32_t ListFTIndexesReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class ListFTIndexesResp final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = ListFTIndexesResp; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + ListFTIndexesResp() : + code( ::nebula::cpp2::ErrorCode::SUCCEEDED) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + ListFTIndexesResp(apache::thrift::FragileConstructor, ::nebula::cpp2::ErrorCode code__arg, nebula::HostAddr leader__arg, std::unordered_map<::std::string, ::nebula::meta::cpp2::FTIndex> indexes__arg); + + ListFTIndexesResp(ListFTIndexesResp&&) = default; + + ListFTIndexesResp(const ListFTIndexesResp&) = default; + + + ListFTIndexesResp& operator=(ListFTIndexesResp&&) = default; + + ListFTIndexesResp& operator=(const ListFTIndexesResp&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::ErrorCode code; + private: + nebula::HostAddr leader; + private: + std::unordered_map<::std::string, ::nebula::meta::cpp2::FTIndex> indexes; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool code; + bool leader; + bool indexes; + } __isset = {}; + bool operator==(const ListFTIndexesResp& rhs) const; +#ifndef SWIG + friend bool operator!=(const ListFTIndexesResp& __x, const ListFTIndexesResp& __y) { + return !(__x == __y); + } +#endif + bool operator<(const ListFTIndexesResp& rhs) const; +#ifndef SWIG + friend bool operator>(const ListFTIndexesResp& __x, const ListFTIndexesResp& __y) { + return __y < __x; + } + friend bool operator<=(const ListFTIndexesResp& __x, const ListFTIndexesResp& __y) { + return !(__y < __x); + } + friend bool operator>=(const ListFTIndexesResp& __x, const ListFTIndexesResp& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() const& { + return {this->code, __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() const&& { + return {std::move(this->code), __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() & { + return {this->code, __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() && { + return {std::move(this->code), __isset.code}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() const& { + return {this->leader, __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() const&& { + return {std::move(this->leader), __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() & { + return {this->leader, __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() && { + return {std::move(this->leader), __isset.leader}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::field_ref indexes_ref() const& { + return {this->indexes, __isset.indexes}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref indexes_ref() const&& { + return {std::move(this->indexes), __isset.indexes}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref indexes_ref() & { + return {this->indexes, __isset.indexes}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref indexes_ref() && { + return {std::move(this->indexes), __isset.indexes}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::ErrorCode get_code() const { + return code; + } + + ::nebula::cpp2::ErrorCode& set_code( ::nebula::cpp2::ErrorCode code_) { + code = code_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.code = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return code; + } + const nebula::HostAddr& get_leader() const&; + nebula::HostAddr get_leader() &&; + + template + nebula::HostAddr& set_leader(T_ListFTIndexesResp_leader_struct_setter&& leader_) { + leader = std::forward(leader_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.leader = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return leader; + } + const std::unordered_map<::std::string, ::nebula::meta::cpp2::FTIndex>& get_indexes() const&; + std::unordered_map<::std::string, ::nebula::meta::cpp2::FTIndex> get_indexes() &&; + + template > + std::unordered_map<::std::string, ::nebula::meta::cpp2::FTIndex>& set_indexes(T_ListFTIndexesResp_indexes_struct_setter&& indexes_) { + indexes = std::forward(indexes_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.indexes = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return indexes; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< ListFTIndexesResp >; + friend void swap(ListFTIndexesResp& a, ListFTIndexesResp& b); +}; + +template +uint32_t ListFTIndexesResp::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class QueryDesc final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = QueryDesc; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + + QueryDesc(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + QueryDesc(apache::thrift::FragileConstructor, ::nebula::cpp2::Timestamp start_time__arg, ::nebula::meta::cpp2::QueryStatus status__arg, int64_t duration__arg, ::std::string query__arg, nebula::HostAddr graph_addr__arg); + + QueryDesc(QueryDesc&&) = default; + + QueryDesc(const QueryDesc&) = default; + + + QueryDesc& operator=(QueryDesc&&) = default; + + QueryDesc& operator=(const QueryDesc&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + + ~QueryDesc(); + + private: + ::nebula::cpp2::Timestamp start_time; + private: + ::nebula::meta::cpp2::QueryStatus status; + private: + int64_t duration; + private: + ::std::string query; + private: + nebula::HostAddr graph_addr; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool start_time; + bool status; + bool duration; + bool query; + bool graph_addr; + } __isset = {}; + bool operator==(const QueryDesc& rhs) const; +#ifndef SWIG + friend bool operator!=(const QueryDesc& __x, const QueryDesc& __y) { + return !(__x == __y); + } +#endif + bool operator<(const QueryDesc& rhs) const; +#ifndef SWIG + friend bool operator>(const QueryDesc& __x, const QueryDesc& __y) { + return __y < __x; + } + friend bool operator<=(const QueryDesc& __x, const QueryDesc& __y) { + return !(__y < __x); + } + friend bool operator>=(const QueryDesc& __x, const QueryDesc& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref start_time_ref() const& { + return {this->start_time, __isset.start_time}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref start_time_ref() const&& { + return {std::move(this->start_time), __isset.start_time}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref start_time_ref() & { + return {this->start_time, __isset.start_time}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref start_time_ref() && { + return {std::move(this->start_time), __isset.start_time}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref status_ref() const& { + return {this->status, __isset.status}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref status_ref() const&& { + return {std::move(this->status), __isset.status}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref status_ref() & { + return {this->status, __isset.status}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref status_ref() && { + return {std::move(this->status), __isset.status}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref duration_ref() const& { + return {this->duration, __isset.duration}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref duration_ref() const&& { + return {std::move(this->duration), __isset.duration}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref duration_ref() & { + return {this->duration, __isset.duration}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref duration_ref() && { + return {std::move(this->duration), __isset.duration}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref query_ref() const& { + return {this->query, __isset.query}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref query_ref() const&& { + return {std::move(this->query), __isset.query}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref query_ref() & { + return {this->query, __isset.query}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref query_ref() && { + return {std::move(this->query), __isset.query}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref graph_addr_ref() const& { + return {this->graph_addr, __isset.graph_addr}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref graph_addr_ref() const&& { + return {std::move(this->graph_addr), __isset.graph_addr}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref graph_addr_ref() & { + return {this->graph_addr, __isset.graph_addr}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref graph_addr_ref() && { + return {std::move(this->graph_addr), __isset.graph_addr}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::Timestamp get_start_time() const { + return start_time; + } + + ::nebula::cpp2::Timestamp& set_start_time( ::nebula::cpp2::Timestamp start_time_) { + start_time = start_time_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.start_time = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return start_time; + } + + ::nebula::meta::cpp2::QueryStatus get_status() const { + return status; + } + + ::nebula::meta::cpp2::QueryStatus& set_status( ::nebula::meta::cpp2::QueryStatus status_) { + status = status_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.status = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return status; + } + + int64_t get_duration() const { + return duration; + } + + int64_t& set_duration(int64_t duration_) { + duration = duration_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.duration = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return duration; + } + + const ::std::string& get_query() const& { + return query; + } + + ::std::string get_query() && { + return std::move(query); + } + + template + ::std::string& set_query(T_QueryDesc_query_struct_setter&& query_) { + query = std::forward(query_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.query = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return query; + } + const nebula::HostAddr& get_graph_addr() const&; + nebula::HostAddr get_graph_addr() &&; + + template + nebula::HostAddr& set_graph_addr(T_QueryDesc_graph_addr_struct_setter&& graph_addr_) { + graph_addr = std::forward(graph_addr_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.graph_addr = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return graph_addr; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< QueryDesc >; + friend void swap(QueryDesc& a, QueryDesc& b); +}; + +template +uint32_t QueryDesc::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class Session final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = Session; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + + Session(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + Session(apache::thrift::FragileConstructor, ::nebula::cpp2::SessionID session_id__arg, ::nebula::cpp2::Timestamp create_time__arg, ::nebula::cpp2::Timestamp update_time__arg, ::std::string user_name__arg, ::std::string space_name__arg, nebula::HostAddr graph_addr__arg, int32_t timezone__arg, ::std::string client_ip__arg, std::unordered_map<::std::string, nebula::Value> configs__arg, std::unordered_map< ::nebula::cpp2::ExecutionPlanID, ::nebula::meta::cpp2::QueryDesc> queries__arg); + + Session(Session&&) = default; + + Session(const Session&) = default; + + + Session& operator=(Session&&) = default; + + Session& operator=(const Session&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + + ~Session(); + + private: + ::nebula::cpp2::SessionID session_id; + private: + ::nebula::cpp2::Timestamp create_time; + private: + ::nebula::cpp2::Timestamp update_time; + private: + ::std::string user_name; + private: + ::std::string space_name; + private: + nebula::HostAddr graph_addr; + private: + int32_t timezone; + private: + ::std::string client_ip; + private: + std::unordered_map<::std::string, nebula::Value> configs; + private: + std::unordered_map< ::nebula::cpp2::ExecutionPlanID, ::nebula::meta::cpp2::QueryDesc> queries; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool session_id; + bool create_time; + bool update_time; + bool user_name; + bool space_name; + bool graph_addr; + bool timezone; + bool client_ip; + bool configs; + bool queries; + } __isset = {}; + bool operator==(const Session& rhs) const; +#ifndef SWIG + friend bool operator!=(const Session& __x, const Session& __y) { + return !(__x == __y); + } +#endif + bool operator<(const Session& rhs) const; +#ifndef SWIG + friend bool operator>(const Session& __x, const Session& __y) { + return __y < __x; + } + friend bool operator<=(const Session& __x, const Session& __y) { + return !(__y < __x); + } + friend bool operator>=(const Session& __x, const Session& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref session_id_ref() const& { + return {this->session_id, __isset.session_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref session_id_ref() const&& { + return {std::move(this->session_id), __isset.session_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref session_id_ref() & { + return {this->session_id, __isset.session_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref session_id_ref() && { + return {std::move(this->session_id), __isset.session_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref create_time_ref() const& { + return {this->create_time, __isset.create_time}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref create_time_ref() const&& { + return {std::move(this->create_time), __isset.create_time}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref create_time_ref() & { + return {this->create_time, __isset.create_time}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref create_time_ref() && { + return {std::move(this->create_time), __isset.create_time}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref update_time_ref() const& { + return {this->update_time, __isset.update_time}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref update_time_ref() const&& { + return {std::move(this->update_time), __isset.update_time}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref update_time_ref() & { + return {this->update_time, __isset.update_time}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref update_time_ref() && { + return {std::move(this->update_time), __isset.update_time}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref user_name_ref() const& { + return {this->user_name, __isset.user_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref user_name_ref() const&& { + return {std::move(this->user_name), __isset.user_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref user_name_ref() & { + return {this->user_name, __isset.user_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref user_name_ref() && { + return {std::move(this->user_name), __isset.user_name}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref space_name_ref() const& { + return {this->space_name, __isset.space_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_name_ref() const&& { + return {std::move(this->space_name), __isset.space_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_name_ref() & { + return {this->space_name, __isset.space_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_name_ref() && { + return {std::move(this->space_name), __isset.space_name}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref graph_addr_ref() const& { + return {this->graph_addr, __isset.graph_addr}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref graph_addr_ref() const&& { + return {std::move(this->graph_addr), __isset.graph_addr}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref graph_addr_ref() & { + return {this->graph_addr, __isset.graph_addr}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref graph_addr_ref() && { + return {std::move(this->graph_addr), __isset.graph_addr}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref timezone_ref() const& { + return {this->timezone, __isset.timezone}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref timezone_ref() const&& { + return {std::move(this->timezone), __isset.timezone}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref timezone_ref() & { + return {this->timezone, __isset.timezone}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref timezone_ref() && { + return {std::move(this->timezone), __isset.timezone}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref client_ip_ref() const& { + return {this->client_ip, __isset.client_ip}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref client_ip_ref() const&& { + return {std::move(this->client_ip), __isset.client_ip}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref client_ip_ref() & { + return {this->client_ip, __isset.client_ip}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref client_ip_ref() && { + return {std::move(this->client_ip), __isset.client_ip}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::field_ref configs_ref() const& { + return {this->configs, __isset.configs}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref configs_ref() const&& { + return {std::move(this->configs), __isset.configs}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref configs_ref() & { + return {this->configs, __isset.configs}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref configs_ref() && { + return {std::move(this->configs), __isset.configs}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::field_ref queries_ref() const& { + return {this->queries, __isset.queries}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref queries_ref() const&& { + return {std::move(this->queries), __isset.queries}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref queries_ref() & { + return {this->queries, __isset.queries}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref queries_ref() && { + return {std::move(this->queries), __isset.queries}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::SessionID get_session_id() const { + return session_id; + } + + ::nebula::cpp2::SessionID& set_session_id( ::nebula::cpp2::SessionID session_id_) { + session_id = session_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.session_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return session_id; + } + + ::nebula::cpp2::Timestamp get_create_time() const { + return create_time; + } + + ::nebula::cpp2::Timestamp& set_create_time( ::nebula::cpp2::Timestamp create_time_) { + create_time = create_time_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.create_time = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return create_time; + } + + ::nebula::cpp2::Timestamp get_update_time() const { + return update_time; + } + + ::nebula::cpp2::Timestamp& set_update_time( ::nebula::cpp2::Timestamp update_time_) { + update_time = update_time_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.update_time = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return update_time; + } + + const ::std::string& get_user_name() const& { + return user_name; + } + + ::std::string get_user_name() && { + return std::move(user_name); + } + + template + ::std::string& set_user_name(T_Session_user_name_struct_setter&& user_name_) { + user_name = std::forward(user_name_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.user_name = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return user_name; + } + + const ::std::string& get_space_name() const& { + return space_name; + } + + ::std::string get_space_name() && { + return std::move(space_name); + } + + template + ::std::string& set_space_name(T_Session_space_name_struct_setter&& space_name_) { + space_name = std::forward(space_name_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.space_name = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return space_name; + } + const nebula::HostAddr& get_graph_addr() const&; + nebula::HostAddr get_graph_addr() &&; + + template + nebula::HostAddr& set_graph_addr(T_Session_graph_addr_struct_setter&& graph_addr_) { + graph_addr = std::forward(graph_addr_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.graph_addr = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return graph_addr; + } + + int32_t get_timezone() const { + return timezone; + } + + int32_t& set_timezone(int32_t timezone_) { + timezone = timezone_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.timezone = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return timezone; + } + + const ::std::string& get_client_ip() const& { + return client_ip; + } + + ::std::string get_client_ip() && { + return std::move(client_ip); + } + + template + ::std::string& set_client_ip(T_Session_client_ip_struct_setter&& client_ip_) { + client_ip = std::forward(client_ip_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.client_ip = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return client_ip; + } + const std::unordered_map<::std::string, nebula::Value>& get_configs() const&; + std::unordered_map<::std::string, nebula::Value> get_configs() &&; + + template > + std::unordered_map<::std::string, nebula::Value>& set_configs(T_Session_configs_struct_setter&& configs_) { + configs = std::forward(configs_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.configs = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return configs; + } + const std::unordered_map< ::nebula::cpp2::ExecutionPlanID, ::nebula::meta::cpp2::QueryDesc>& get_queries() const&; + std::unordered_map< ::nebula::cpp2::ExecutionPlanID, ::nebula::meta::cpp2::QueryDesc> get_queries() &&; + + template > + std::unordered_map< ::nebula::cpp2::ExecutionPlanID, ::nebula::meta::cpp2::QueryDesc>& set_queries(T_Session_queries_struct_setter&& queries_) { + queries = std::forward(queries_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.queries = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return queries; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< Session >; + friend void swap(Session& a, Session& b); +}; + +template +uint32_t Session::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class CreateSessionReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = CreateSessionReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + CreateSessionReq() {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + CreateSessionReq(apache::thrift::FragileConstructor, ::std::string user__arg, nebula::HostAddr graph_addr__arg, ::std::string client_ip__arg); + + CreateSessionReq(CreateSessionReq&&) = default; + + CreateSessionReq(const CreateSessionReq&) = default; + + + CreateSessionReq& operator=(CreateSessionReq&&) = default; + + CreateSessionReq& operator=(const CreateSessionReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::std::string user; + private: + nebula::HostAddr graph_addr; + private: + ::std::string client_ip; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool user; + bool graph_addr; + bool client_ip; + } __isset = {}; + bool operator==(const CreateSessionReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const CreateSessionReq& __x, const CreateSessionReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const CreateSessionReq& rhs) const; +#ifndef SWIG + friend bool operator>(const CreateSessionReq& __x, const CreateSessionReq& __y) { + return __y < __x; + } + friend bool operator<=(const CreateSessionReq& __x, const CreateSessionReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const CreateSessionReq& __x, const CreateSessionReq& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref user_ref() const& { + return {this->user, __isset.user}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref user_ref() const&& { + return {std::move(this->user), __isset.user}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref user_ref() & { + return {this->user, __isset.user}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref user_ref() && { + return {std::move(this->user), __isset.user}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref graph_addr_ref() const& { + return {this->graph_addr, __isset.graph_addr}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref graph_addr_ref() const&& { + return {std::move(this->graph_addr), __isset.graph_addr}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref graph_addr_ref() & { + return {this->graph_addr, __isset.graph_addr}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref graph_addr_ref() && { + return {std::move(this->graph_addr), __isset.graph_addr}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref client_ip_ref() const& { + return {this->client_ip, __isset.client_ip}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref client_ip_ref() const&& { + return {std::move(this->client_ip), __isset.client_ip}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref client_ip_ref() & { + return {this->client_ip, __isset.client_ip}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref client_ip_ref() && { + return {std::move(this->client_ip), __isset.client_ip}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + const ::std::string& get_user() const& { + return user; + } + + ::std::string get_user() && { + return std::move(user); + } + + template + ::std::string& set_user(T_CreateSessionReq_user_struct_setter&& user_) { + user = std::forward(user_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.user = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return user; + } + const nebula::HostAddr& get_graph_addr() const&; + nebula::HostAddr get_graph_addr() &&; + + template + nebula::HostAddr& set_graph_addr(T_CreateSessionReq_graph_addr_struct_setter&& graph_addr_) { + graph_addr = std::forward(graph_addr_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.graph_addr = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return graph_addr; + } + + const ::std::string& get_client_ip() const& { + return client_ip; + } + + ::std::string get_client_ip() && { + return std::move(client_ip); + } + + template + ::std::string& set_client_ip(T_CreateSessionReq_client_ip_struct_setter&& client_ip_) { + client_ip = std::forward(client_ip_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.client_ip = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return client_ip; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< CreateSessionReq >; + friend void swap(CreateSessionReq& a, CreateSessionReq& b); +}; + +template +uint32_t CreateSessionReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class CreateSessionResp final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = CreateSessionResp; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + CreateSessionResp() : + code( ::nebula::cpp2::ErrorCode::SUCCEEDED) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + CreateSessionResp(apache::thrift::FragileConstructor, ::nebula::cpp2::ErrorCode code__arg, nebula::HostAddr leader__arg, ::nebula::meta::cpp2::Session session__arg); + + CreateSessionResp(CreateSessionResp&&) = default; + + CreateSessionResp(const CreateSessionResp&) = default; + + + CreateSessionResp& operator=(CreateSessionResp&&) = default; + + CreateSessionResp& operator=(const CreateSessionResp&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::ErrorCode code; + private: + nebula::HostAddr leader; + private: + ::nebula::meta::cpp2::Session session; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool code; + bool leader; + bool session; + } __isset = {}; + bool operator==(const CreateSessionResp& rhs) const; +#ifndef SWIG + friend bool operator!=(const CreateSessionResp& __x, const CreateSessionResp& __y) { + return !(__x == __y); + } +#endif + bool operator<(const CreateSessionResp& rhs) const; +#ifndef SWIG + friend bool operator>(const CreateSessionResp& __x, const CreateSessionResp& __y) { + return __y < __x; + } + friend bool operator<=(const CreateSessionResp& __x, const CreateSessionResp& __y) { + return !(__y < __x); + } + friend bool operator>=(const CreateSessionResp& __x, const CreateSessionResp& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() const& { + return {this->code, __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() const&& { + return {std::move(this->code), __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() & { + return {this->code, __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() && { + return {std::move(this->code), __isset.code}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() const& { + return {this->leader, __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() const&& { + return {std::move(this->leader), __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() & { + return {this->leader, __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() && { + return {std::move(this->leader), __isset.leader}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref session_ref() const& { + return {this->session, __isset.session}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref session_ref() const&& { + return {std::move(this->session), __isset.session}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref session_ref() & { + return {this->session, __isset.session}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref session_ref() && { + return {std::move(this->session), __isset.session}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::ErrorCode get_code() const { + return code; + } + + ::nebula::cpp2::ErrorCode& set_code( ::nebula::cpp2::ErrorCode code_) { + code = code_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.code = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return code; + } + const nebula::HostAddr& get_leader() const&; + nebula::HostAddr get_leader() &&; + + template + nebula::HostAddr& set_leader(T_CreateSessionResp_leader_struct_setter&& leader_) { + leader = std::forward(leader_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.leader = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return leader; + } + const ::nebula::meta::cpp2::Session& get_session() const&; + ::nebula::meta::cpp2::Session get_session() &&; + + template + ::nebula::meta::cpp2::Session& set_session(T_CreateSessionResp_session_struct_setter&& session_) { + session = std::forward(session_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.session = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return session; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< CreateSessionResp >; + friend void swap(CreateSessionResp& a, CreateSessionResp& b); +}; + +template +uint32_t CreateSessionResp::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class UpdateSessionsReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = UpdateSessionsReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + UpdateSessionsReq() {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + UpdateSessionsReq(apache::thrift::FragileConstructor, ::std::vector< ::nebula::meta::cpp2::Session> sessions__arg); + + UpdateSessionsReq(UpdateSessionsReq&&) = default; + + UpdateSessionsReq(const UpdateSessionsReq&) = default; + + + UpdateSessionsReq& operator=(UpdateSessionsReq&&) = default; + + UpdateSessionsReq& operator=(const UpdateSessionsReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::std::vector< ::nebula::meta::cpp2::Session> sessions; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool sessions; + } __isset = {}; + bool operator==(const UpdateSessionsReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const UpdateSessionsReq& __x, const UpdateSessionsReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const UpdateSessionsReq& rhs) const; +#ifndef SWIG + friend bool operator>(const UpdateSessionsReq& __x, const UpdateSessionsReq& __y) { + return __y < __x; + } + friend bool operator<=(const UpdateSessionsReq& __x, const UpdateSessionsReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const UpdateSessionsReq& __x, const UpdateSessionsReq& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::field_ref sessions_ref() const& { + return {this->sessions, __isset.sessions}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref sessions_ref() const&& { + return {std::move(this->sessions), __isset.sessions}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref sessions_ref() & { + return {this->sessions, __isset.sessions}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref sessions_ref() && { + return {std::move(this->sessions), __isset.sessions}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + const ::std::vector< ::nebula::meta::cpp2::Session>& get_sessions() const&; + ::std::vector< ::nebula::meta::cpp2::Session> get_sessions() &&; + + template > + ::std::vector< ::nebula::meta::cpp2::Session>& set_sessions(T_UpdateSessionsReq_sessions_struct_setter&& sessions_) { + sessions = std::forward(sessions_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.sessions = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return sessions; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< UpdateSessionsReq >; + friend void swap(UpdateSessionsReq& a, UpdateSessionsReq& b); +}; + +template +uint32_t UpdateSessionsReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class UpdateSessionsResp final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = UpdateSessionsResp; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + UpdateSessionsResp() : + code( ::nebula::cpp2::ErrorCode::SUCCEEDED) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + UpdateSessionsResp(apache::thrift::FragileConstructor, ::nebula::cpp2::ErrorCode code__arg, nebula::HostAddr leader__arg, std::unordered_map< ::nebula::cpp2::SessionID, std::unordered_map< ::nebula::cpp2::ExecutionPlanID, ::nebula::meta::cpp2::QueryDesc>> killed_queries__arg); + + UpdateSessionsResp(UpdateSessionsResp&&) = default; + + UpdateSessionsResp(const UpdateSessionsResp&) = default; + + + UpdateSessionsResp& operator=(UpdateSessionsResp&&) = default; + + UpdateSessionsResp& operator=(const UpdateSessionsResp&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::ErrorCode code; + private: + nebula::HostAddr leader; + private: + std::unordered_map< ::nebula::cpp2::SessionID, std::unordered_map< ::nebula::cpp2::ExecutionPlanID, ::nebula::meta::cpp2::QueryDesc>> killed_queries; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool code; + bool leader; + bool killed_queries; + } __isset = {}; + bool operator==(const UpdateSessionsResp& rhs) const; +#ifndef SWIG + friend bool operator!=(const UpdateSessionsResp& __x, const UpdateSessionsResp& __y) { + return !(__x == __y); + } +#endif + bool operator<(const UpdateSessionsResp& rhs) const; +#ifndef SWIG + friend bool operator>(const UpdateSessionsResp& __x, const UpdateSessionsResp& __y) { + return __y < __x; + } + friend bool operator<=(const UpdateSessionsResp& __x, const UpdateSessionsResp& __y) { + return !(__y < __x); + } + friend bool operator>=(const UpdateSessionsResp& __x, const UpdateSessionsResp& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() const& { + return {this->code, __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() const&& { + return {std::move(this->code), __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() & { + return {this->code, __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() && { + return {std::move(this->code), __isset.code}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() const& { + return {this->leader, __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() const&& { + return {std::move(this->leader), __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() & { + return {this->leader, __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() && { + return {std::move(this->leader), __isset.leader}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template >> + FOLLY_ERASE ::apache::thrift::field_ref killed_queries_ref() const& { + return {this->killed_queries, __isset.killed_queries}; + } + + template >> + FOLLY_ERASE ::apache::thrift::field_ref killed_queries_ref() const&& { + return {std::move(this->killed_queries), __isset.killed_queries}; + } + + template >> + FOLLY_ERASE ::apache::thrift::field_ref killed_queries_ref() & { + return {this->killed_queries, __isset.killed_queries}; + } + + template >> + FOLLY_ERASE ::apache::thrift::field_ref killed_queries_ref() && { + return {std::move(this->killed_queries), __isset.killed_queries}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::ErrorCode get_code() const { + return code; + } + + ::nebula::cpp2::ErrorCode& set_code( ::nebula::cpp2::ErrorCode code_) { + code = code_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.code = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return code; + } + const nebula::HostAddr& get_leader() const&; + nebula::HostAddr get_leader() &&; + + template + nebula::HostAddr& set_leader(T_UpdateSessionsResp_leader_struct_setter&& leader_) { + leader = std::forward(leader_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.leader = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return leader; + } + const std::unordered_map< ::nebula::cpp2::SessionID, std::unordered_map< ::nebula::cpp2::ExecutionPlanID, ::nebula::meta::cpp2::QueryDesc>>& get_killed_queries() const&; + std::unordered_map< ::nebula::cpp2::SessionID, std::unordered_map< ::nebula::cpp2::ExecutionPlanID, ::nebula::meta::cpp2::QueryDesc>> get_killed_queries() &&; + + template >> + std::unordered_map< ::nebula::cpp2::SessionID, std::unordered_map< ::nebula::cpp2::ExecutionPlanID, ::nebula::meta::cpp2::QueryDesc>>& set_killed_queries(T_UpdateSessionsResp_killed_queries_struct_setter&& killed_queries_) { + killed_queries = std::forward(killed_queries_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.killed_queries = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return killed_queries; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< UpdateSessionsResp >; + friend void swap(UpdateSessionsResp& a, UpdateSessionsResp& b); +}; + +template +uint32_t UpdateSessionsResp::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class ListSessionsReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = ListSessionsReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + ListSessionsReq() {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + ListSessionsReq(apache::thrift::FragileConstructor); + + ListSessionsReq(ListSessionsReq&&) = default; + + ListSessionsReq(const ListSessionsReq&) = default; + + + ListSessionsReq& operator=(ListSessionsReq&&) = default; + + ListSessionsReq& operator=(const ListSessionsReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + bool operator==(const ListSessionsReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const ListSessionsReq& __x, const ListSessionsReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const ListSessionsReq& rhs) const; +#ifndef SWIG + friend bool operator>(const ListSessionsReq& __x, const ListSessionsReq& __y) { + return __y < __x; + } + friend bool operator<=(const ListSessionsReq& __x, const ListSessionsReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const ListSessionsReq& __x, const ListSessionsReq& __y) { + return !(__x < __y); + } +#endif + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< ListSessionsReq >; + friend void swap(ListSessionsReq& a, ListSessionsReq& b); +}; + +template +uint32_t ListSessionsReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class ListSessionsResp final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = ListSessionsResp; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + ListSessionsResp() : + code( ::nebula::cpp2::ErrorCode::SUCCEEDED) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + ListSessionsResp(apache::thrift::FragileConstructor, ::nebula::cpp2::ErrorCode code__arg, nebula::HostAddr leader__arg, ::std::vector< ::nebula::meta::cpp2::Session> sessions__arg); + + ListSessionsResp(ListSessionsResp&&) = default; + + ListSessionsResp(const ListSessionsResp&) = default; + + + ListSessionsResp& operator=(ListSessionsResp&&) = default; + + ListSessionsResp& operator=(const ListSessionsResp&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::ErrorCode code; + private: + nebula::HostAddr leader; + private: + ::std::vector< ::nebula::meta::cpp2::Session> sessions; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool code; + bool leader; + bool sessions; + } __isset = {}; + bool operator==(const ListSessionsResp& rhs) const; +#ifndef SWIG + friend bool operator!=(const ListSessionsResp& __x, const ListSessionsResp& __y) { + return !(__x == __y); + } +#endif + bool operator<(const ListSessionsResp& rhs) const; +#ifndef SWIG + friend bool operator>(const ListSessionsResp& __x, const ListSessionsResp& __y) { + return __y < __x; + } + friend bool operator<=(const ListSessionsResp& __x, const ListSessionsResp& __y) { + return !(__y < __x); + } + friend bool operator>=(const ListSessionsResp& __x, const ListSessionsResp& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() const& { + return {this->code, __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() const&& { + return {std::move(this->code), __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() & { + return {this->code, __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() && { + return {std::move(this->code), __isset.code}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() const& { + return {this->leader, __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() const&& { + return {std::move(this->leader), __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() & { + return {this->leader, __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() && { + return {std::move(this->leader), __isset.leader}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::field_ref sessions_ref() const& { + return {this->sessions, __isset.sessions}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref sessions_ref() const&& { + return {std::move(this->sessions), __isset.sessions}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref sessions_ref() & { + return {this->sessions, __isset.sessions}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref sessions_ref() && { + return {std::move(this->sessions), __isset.sessions}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::ErrorCode get_code() const { + return code; + } + + ::nebula::cpp2::ErrorCode& set_code( ::nebula::cpp2::ErrorCode code_) { + code = code_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.code = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return code; + } + const nebula::HostAddr& get_leader() const&; + nebula::HostAddr get_leader() &&; + + template + nebula::HostAddr& set_leader(T_ListSessionsResp_leader_struct_setter&& leader_) { + leader = std::forward(leader_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.leader = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return leader; + } + const ::std::vector< ::nebula::meta::cpp2::Session>& get_sessions() const&; + ::std::vector< ::nebula::meta::cpp2::Session> get_sessions() &&; + + template > + ::std::vector< ::nebula::meta::cpp2::Session>& set_sessions(T_ListSessionsResp_sessions_struct_setter&& sessions_) { + sessions = std::forward(sessions_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.sessions = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return sessions; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< ListSessionsResp >; + friend void swap(ListSessionsResp& a, ListSessionsResp& b); +}; + +template +uint32_t ListSessionsResp::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class GetSessionReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = GetSessionReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + GetSessionReq() : + session_id(0) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + GetSessionReq(apache::thrift::FragileConstructor, ::nebula::cpp2::SessionID session_id__arg); + + GetSessionReq(GetSessionReq&&) = default; + + GetSessionReq(const GetSessionReq&) = default; + + + GetSessionReq& operator=(GetSessionReq&&) = default; + + GetSessionReq& operator=(const GetSessionReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::SessionID session_id; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool session_id; + } __isset = {}; + bool operator==(const GetSessionReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const GetSessionReq& __x, const GetSessionReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const GetSessionReq& rhs) const; +#ifndef SWIG + friend bool operator>(const GetSessionReq& __x, const GetSessionReq& __y) { + return __y < __x; + } + friend bool operator<=(const GetSessionReq& __x, const GetSessionReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const GetSessionReq& __x, const GetSessionReq& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref session_id_ref() const& { + return {this->session_id, __isset.session_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref session_id_ref() const&& { + return {std::move(this->session_id), __isset.session_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref session_id_ref() & { + return {this->session_id, __isset.session_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref session_id_ref() && { + return {std::move(this->session_id), __isset.session_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::SessionID get_session_id() const { + return session_id; + } + + ::nebula::cpp2::SessionID& set_session_id( ::nebula::cpp2::SessionID session_id_) { + session_id = session_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.session_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return session_id; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< GetSessionReq >; + friend void swap(GetSessionReq& a, GetSessionReq& b); +}; + +template +uint32_t GetSessionReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class GetSessionResp final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = GetSessionResp; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + GetSessionResp() : + code( ::nebula::cpp2::ErrorCode::SUCCEEDED) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + GetSessionResp(apache::thrift::FragileConstructor, ::nebula::cpp2::ErrorCode code__arg, nebula::HostAddr leader__arg, ::nebula::meta::cpp2::Session session__arg); + + GetSessionResp(GetSessionResp&&) = default; + + GetSessionResp(const GetSessionResp&) = default; + + + GetSessionResp& operator=(GetSessionResp&&) = default; + + GetSessionResp& operator=(const GetSessionResp&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::ErrorCode code; + private: + nebula::HostAddr leader; + private: + ::nebula::meta::cpp2::Session session; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool code; + bool leader; + bool session; + } __isset = {}; + bool operator==(const GetSessionResp& rhs) const; +#ifndef SWIG + friend bool operator!=(const GetSessionResp& __x, const GetSessionResp& __y) { + return !(__x == __y); + } +#endif + bool operator<(const GetSessionResp& rhs) const; +#ifndef SWIG + friend bool operator>(const GetSessionResp& __x, const GetSessionResp& __y) { + return __y < __x; + } + friend bool operator<=(const GetSessionResp& __x, const GetSessionResp& __y) { + return !(__y < __x); + } + friend bool operator>=(const GetSessionResp& __x, const GetSessionResp& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() const& { + return {this->code, __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() const&& { + return {std::move(this->code), __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() & { + return {this->code, __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() && { + return {std::move(this->code), __isset.code}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() const& { + return {this->leader, __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() const&& { + return {std::move(this->leader), __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() & { + return {this->leader, __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() && { + return {std::move(this->leader), __isset.leader}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref session_ref() const& { + return {this->session, __isset.session}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref session_ref() const&& { + return {std::move(this->session), __isset.session}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref session_ref() & { + return {this->session, __isset.session}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref session_ref() && { + return {std::move(this->session), __isset.session}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::ErrorCode get_code() const { + return code; + } + + ::nebula::cpp2::ErrorCode& set_code( ::nebula::cpp2::ErrorCode code_) { + code = code_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.code = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return code; + } + const nebula::HostAddr& get_leader() const&; + nebula::HostAddr get_leader() &&; + + template + nebula::HostAddr& set_leader(T_GetSessionResp_leader_struct_setter&& leader_) { + leader = std::forward(leader_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.leader = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return leader; + } + const ::nebula::meta::cpp2::Session& get_session() const&; + ::nebula::meta::cpp2::Session get_session() &&; + + template + ::nebula::meta::cpp2::Session& set_session(T_GetSessionResp_session_struct_setter&& session_) { + session = std::forward(session_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.session = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return session; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< GetSessionResp >; + friend void swap(GetSessionResp& a, GetSessionResp& b); +}; + +template +uint32_t GetSessionResp::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class RemoveSessionReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = RemoveSessionReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + RemoveSessionReq() : + session_id(0) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + RemoveSessionReq(apache::thrift::FragileConstructor, ::nebula::cpp2::SessionID session_id__arg); + + RemoveSessionReq(RemoveSessionReq&&) = default; + + RemoveSessionReq(const RemoveSessionReq&) = default; + + + RemoveSessionReq& operator=(RemoveSessionReq&&) = default; + + RemoveSessionReq& operator=(const RemoveSessionReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::SessionID session_id; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool session_id; + } __isset = {}; + bool operator==(const RemoveSessionReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const RemoveSessionReq& __x, const RemoveSessionReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const RemoveSessionReq& rhs) const; +#ifndef SWIG + friend bool operator>(const RemoveSessionReq& __x, const RemoveSessionReq& __y) { + return __y < __x; + } + friend bool operator<=(const RemoveSessionReq& __x, const RemoveSessionReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const RemoveSessionReq& __x, const RemoveSessionReq& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref session_id_ref() const& { + return {this->session_id, __isset.session_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref session_id_ref() const&& { + return {std::move(this->session_id), __isset.session_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref session_id_ref() & { + return {this->session_id, __isset.session_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref session_id_ref() && { + return {std::move(this->session_id), __isset.session_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::SessionID get_session_id() const { + return session_id; + } + + ::nebula::cpp2::SessionID& set_session_id( ::nebula::cpp2::SessionID session_id_) { + session_id = session_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.session_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return session_id; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< RemoveSessionReq >; + friend void swap(RemoveSessionReq& a, RemoveSessionReq& b); +}; + +template +uint32_t RemoveSessionReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class KillQueryReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = KillQueryReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + KillQueryReq() {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + KillQueryReq(apache::thrift::FragileConstructor, std::unordered_map< ::nebula::cpp2::SessionID, std::unordered_set< ::nebula::cpp2::ExecutionPlanID>> kill_queries__arg); + + KillQueryReq(KillQueryReq&&) = default; + + KillQueryReq(const KillQueryReq&) = default; + + + KillQueryReq& operator=(KillQueryReq&&) = default; + + KillQueryReq& operator=(const KillQueryReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + std::unordered_map< ::nebula::cpp2::SessionID, std::unordered_set< ::nebula::cpp2::ExecutionPlanID>> kill_queries; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool kill_queries; + } __isset = {}; + bool operator==(const KillQueryReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const KillQueryReq& __x, const KillQueryReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const KillQueryReq& rhs) const; +#ifndef SWIG + friend bool operator>(const KillQueryReq& __x, const KillQueryReq& __y) { + return __y < __x; + } + friend bool operator<=(const KillQueryReq& __x, const KillQueryReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const KillQueryReq& __x, const KillQueryReq& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template >> + FOLLY_ERASE ::apache::thrift::field_ref kill_queries_ref() const& { + return {this->kill_queries, __isset.kill_queries}; + } + + template >> + FOLLY_ERASE ::apache::thrift::field_ref kill_queries_ref() const&& { + return {std::move(this->kill_queries), __isset.kill_queries}; + } + + template >> + FOLLY_ERASE ::apache::thrift::field_ref kill_queries_ref() & { + return {this->kill_queries, __isset.kill_queries}; + } + + template >> + FOLLY_ERASE ::apache::thrift::field_ref kill_queries_ref() && { + return {std::move(this->kill_queries), __isset.kill_queries}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + const std::unordered_map< ::nebula::cpp2::SessionID, std::unordered_set< ::nebula::cpp2::ExecutionPlanID>>& get_kill_queries() const&; + std::unordered_map< ::nebula::cpp2::SessionID, std::unordered_set< ::nebula::cpp2::ExecutionPlanID>> get_kill_queries() &&; + + template >> + std::unordered_map< ::nebula::cpp2::SessionID, std::unordered_set< ::nebula::cpp2::ExecutionPlanID>>& set_kill_queries(T_KillQueryReq_kill_queries_struct_setter&& kill_queries_) { + kill_queries = std::forward(kill_queries_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.kill_queries = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return kill_queries; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< KillQueryReq >; + friend void swap(KillQueryReq& a, KillQueryReq& b); +}; + +template +uint32_t KillQueryReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class ReportTaskReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = ReportTaskReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + ReportTaskReq() : + code( ::nebula::cpp2::ErrorCode::SUCCEEDED), + job_id(0), + task_id(0) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + ReportTaskReq(apache::thrift::FragileConstructor, ::nebula::cpp2::ErrorCode code__arg, int32_t job_id__arg, int32_t task_id__arg, ::nebula::meta::cpp2::StatsItem stats__arg); + + ReportTaskReq(ReportTaskReq&&) = default; + + ReportTaskReq(const ReportTaskReq&) = default; + + + ReportTaskReq& operator=(ReportTaskReq&&) = default; + + ReportTaskReq& operator=(const ReportTaskReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::ErrorCode code; + private: + int32_t job_id; + private: + int32_t task_id; + private: + ::nebula::meta::cpp2::StatsItem stats; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool code; + bool job_id; + bool task_id; + bool stats; + } __isset = {}; + bool operator==(const ReportTaskReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const ReportTaskReq& __x, const ReportTaskReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const ReportTaskReq& rhs) const; +#ifndef SWIG + friend bool operator>(const ReportTaskReq& __x, const ReportTaskReq& __y) { + return __y < __x; + } + friend bool operator<=(const ReportTaskReq& __x, const ReportTaskReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const ReportTaskReq& __x, const ReportTaskReq& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() const& { + return {this->code, __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() const&& { + return {std::move(this->code), __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() & { + return {this->code, __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() && { + return {std::move(this->code), __isset.code}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref job_id_ref() const& { + return {this->job_id, __isset.job_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref job_id_ref() const&& { + return {std::move(this->job_id), __isset.job_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref job_id_ref() & { + return {this->job_id, __isset.job_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref job_id_ref() && { + return {std::move(this->job_id), __isset.job_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref task_id_ref() const& { + return {this->task_id, __isset.task_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref task_id_ref() const&& { + return {std::move(this->task_id), __isset.task_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref task_id_ref() & { + return {this->task_id, __isset.task_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref task_id_ref() && { + return {std::move(this->task_id), __isset.task_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::optional_field_ref stats_ref() const& { + return {this->stats, __isset.stats}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref stats_ref() const&& { + return {std::move(this->stats), __isset.stats}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref stats_ref() & { + return {this->stats, __isset.stats}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref stats_ref() && { + return {std::move(this->stats), __isset.stats}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::ErrorCode get_code() const { + return code; + } + + ::nebula::cpp2::ErrorCode& set_code( ::nebula::cpp2::ErrorCode code_) { + code = code_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.code = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return code; + } + + int32_t get_job_id() const { + return job_id; + } + + int32_t& set_job_id(int32_t job_id_) { + job_id = job_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.job_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return job_id; + } + + int32_t get_task_id() const { + return task_id; + } + + int32_t& set_task_id(int32_t task_id_) { + task_id = task_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.task_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return task_id; + } + const ::nebula::meta::cpp2::StatsItem* get_stats() const&; + ::nebula::meta::cpp2::StatsItem* get_stats() &; + ::nebula::meta::cpp2::StatsItem* get_stats() && = delete; + + template + ::nebula::meta::cpp2::StatsItem& set_stats(T_ReportTaskReq_stats_struct_setter&& stats_) { + stats = std::forward(stats_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.stats = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return stats; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< ReportTaskReq >; + friend void swap(ReportTaskReq& a, ReportTaskReq& b); +}; + +template +uint32_t ReportTaskReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class ListClusterInfoResp final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = ListClusterInfoResp; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + ListClusterInfoResp() : + code( ::nebula::cpp2::ErrorCode::SUCCEEDED) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + ListClusterInfoResp(apache::thrift::FragileConstructor, ::nebula::cpp2::ErrorCode code__arg, nebula::HostAddr leader__arg, ::std::vector meta_servers__arg, ::std::vector< ::nebula::cpp2::NodeInfo> storage_servers__arg); + + ListClusterInfoResp(ListClusterInfoResp&&) = default; + + ListClusterInfoResp(const ListClusterInfoResp&) = default; + + + ListClusterInfoResp& operator=(ListClusterInfoResp&&) = default; + + ListClusterInfoResp& operator=(const ListClusterInfoResp&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::ErrorCode code; + private: + nebula::HostAddr leader; + private: + ::std::vector meta_servers; + private: + ::std::vector< ::nebula::cpp2::NodeInfo> storage_servers; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool code; + bool leader; + bool meta_servers; + bool storage_servers; + } __isset = {}; + bool operator==(const ListClusterInfoResp& rhs) const; +#ifndef SWIG + friend bool operator!=(const ListClusterInfoResp& __x, const ListClusterInfoResp& __y) { + return !(__x == __y); + } +#endif + bool operator<(const ListClusterInfoResp& rhs) const; +#ifndef SWIG + friend bool operator>(const ListClusterInfoResp& __x, const ListClusterInfoResp& __y) { + return __y < __x; + } + friend bool operator<=(const ListClusterInfoResp& __x, const ListClusterInfoResp& __y) { + return !(__y < __x); + } + friend bool operator>=(const ListClusterInfoResp& __x, const ListClusterInfoResp& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() const& { + return {this->code, __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() const&& { + return {std::move(this->code), __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() & { + return {this->code, __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() && { + return {std::move(this->code), __isset.code}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() const& { + return {this->leader, __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() const&& { + return {std::move(this->leader), __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() & { + return {this->leader, __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() && { + return {std::move(this->leader), __isset.leader}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::field_ref meta_servers_ref() const& { + return {this->meta_servers, __isset.meta_servers}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref meta_servers_ref() const&& { + return {std::move(this->meta_servers), __isset.meta_servers}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref meta_servers_ref() & { + return {this->meta_servers, __isset.meta_servers}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref meta_servers_ref() && { + return {std::move(this->meta_servers), __isset.meta_servers}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::field_ref storage_servers_ref() const& { + return {this->storage_servers, __isset.storage_servers}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref storage_servers_ref() const&& { + return {std::move(this->storage_servers), __isset.storage_servers}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref storage_servers_ref() & { + return {this->storage_servers, __isset.storage_servers}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref storage_servers_ref() && { + return {std::move(this->storage_servers), __isset.storage_servers}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::ErrorCode get_code() const { + return code; + } + + ::nebula::cpp2::ErrorCode& set_code( ::nebula::cpp2::ErrorCode code_) { + code = code_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.code = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return code; + } + const nebula::HostAddr& get_leader() const&; + nebula::HostAddr get_leader() &&; + + template + nebula::HostAddr& set_leader(T_ListClusterInfoResp_leader_struct_setter&& leader_) { + leader = std::forward(leader_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.leader = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return leader; + } + const ::std::vector& get_meta_servers() const&; + ::std::vector get_meta_servers() &&; + + template > + ::std::vector& set_meta_servers(T_ListClusterInfoResp_meta_servers_struct_setter&& meta_servers_) { + meta_servers = std::forward(meta_servers_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.meta_servers = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return meta_servers; + } + const ::std::vector< ::nebula::cpp2::NodeInfo>& get_storage_servers() const&; + ::std::vector< ::nebula::cpp2::NodeInfo> get_storage_servers() &&; + + template > + ::std::vector< ::nebula::cpp2::NodeInfo>& set_storage_servers(T_ListClusterInfoResp_storage_servers_struct_setter&& storage_servers_) { + storage_servers = std::forward(storage_servers_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.storage_servers = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return storage_servers; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< ListClusterInfoResp >; + friend void swap(ListClusterInfoResp& a, ListClusterInfoResp& b); +}; + +template +uint32_t ListClusterInfoResp::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class ListClusterInfoReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = ListClusterInfoReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + ListClusterInfoReq() {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + ListClusterInfoReq(apache::thrift::FragileConstructor); + + ListClusterInfoReq(ListClusterInfoReq&&) = default; + + ListClusterInfoReq(const ListClusterInfoReq&) = default; + + + ListClusterInfoReq& operator=(ListClusterInfoReq&&) = default; + + ListClusterInfoReq& operator=(const ListClusterInfoReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + bool operator==(const ListClusterInfoReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const ListClusterInfoReq& __x, const ListClusterInfoReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const ListClusterInfoReq& rhs) const; +#ifndef SWIG + friend bool operator>(const ListClusterInfoReq& __x, const ListClusterInfoReq& __y) { + return __y < __x; + } + friend bool operator<=(const ListClusterInfoReq& __x, const ListClusterInfoReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const ListClusterInfoReq& __x, const ListClusterInfoReq& __y) { + return !(__x < __y); + } +#endif + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< ListClusterInfoReq >; + friend void swap(ListClusterInfoReq& a, ListClusterInfoReq& b); +}; + +template +uint32_t ListClusterInfoReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class GetMetaDirInfoResp final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = GetMetaDirInfoResp; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + GetMetaDirInfoResp() : + code( ::nebula::cpp2::ErrorCode::SUCCEEDED) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + GetMetaDirInfoResp(apache::thrift::FragileConstructor, ::nebula::cpp2::ErrorCode code__arg, ::nebula::cpp2::DirInfo dir__arg); + + GetMetaDirInfoResp(GetMetaDirInfoResp&&) = default; + + GetMetaDirInfoResp(const GetMetaDirInfoResp&) = default; + + + GetMetaDirInfoResp& operator=(GetMetaDirInfoResp&&) = default; + + GetMetaDirInfoResp& operator=(const GetMetaDirInfoResp&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::ErrorCode code; + private: + ::nebula::cpp2::DirInfo dir; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool code; + bool dir; + } __isset = {}; + bool operator==(const GetMetaDirInfoResp& rhs) const; +#ifndef SWIG + friend bool operator!=(const GetMetaDirInfoResp& __x, const GetMetaDirInfoResp& __y) { + return !(__x == __y); + } +#endif + bool operator<(const GetMetaDirInfoResp& rhs) const; +#ifndef SWIG + friend bool operator>(const GetMetaDirInfoResp& __x, const GetMetaDirInfoResp& __y) { + return __y < __x; + } + friend bool operator<=(const GetMetaDirInfoResp& __x, const GetMetaDirInfoResp& __y) { + return !(__y < __x); + } + friend bool operator>=(const GetMetaDirInfoResp& __x, const GetMetaDirInfoResp& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() const& { + return {this->code, __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() const&& { + return {std::move(this->code), __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() & { + return {this->code, __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() && { + return {std::move(this->code), __isset.code}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref dir_ref() const& { + return {this->dir, __isset.dir}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref dir_ref() const&& { + return {std::move(this->dir), __isset.dir}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref dir_ref() & { + return {this->dir, __isset.dir}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref dir_ref() && { + return {std::move(this->dir), __isset.dir}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::ErrorCode get_code() const { + return code; + } + + ::nebula::cpp2::ErrorCode& set_code( ::nebula::cpp2::ErrorCode code_) { + code = code_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.code = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return code; + } + const ::nebula::cpp2::DirInfo& get_dir() const&; + ::nebula::cpp2::DirInfo get_dir() &&; + + template + ::nebula::cpp2::DirInfo& set_dir(T_GetMetaDirInfoResp_dir_struct_setter&& dir_) { + dir = std::forward(dir_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.dir = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return dir; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< GetMetaDirInfoResp >; + friend void swap(GetMetaDirInfoResp& a, GetMetaDirInfoResp& b); +}; + +template +uint32_t GetMetaDirInfoResp::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class GetMetaDirInfoReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = GetMetaDirInfoReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + GetMetaDirInfoReq() {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + GetMetaDirInfoReq(apache::thrift::FragileConstructor); + + GetMetaDirInfoReq(GetMetaDirInfoReq&&) = default; + + GetMetaDirInfoReq(const GetMetaDirInfoReq&) = default; + + + GetMetaDirInfoReq& operator=(GetMetaDirInfoReq&&) = default; + + GetMetaDirInfoReq& operator=(const GetMetaDirInfoReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + bool operator==(const GetMetaDirInfoReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const GetMetaDirInfoReq& __x, const GetMetaDirInfoReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const GetMetaDirInfoReq& rhs) const; +#ifndef SWIG + friend bool operator>(const GetMetaDirInfoReq& __x, const GetMetaDirInfoReq& __y) { + return __y < __x; + } + friend bool operator<=(const GetMetaDirInfoReq& __x, const GetMetaDirInfoReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const GetMetaDirInfoReq& __x, const GetMetaDirInfoReq& __y) { + return !(__x < __y); + } +#endif + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< GetMetaDirInfoReq >; + friend void swap(GetMetaDirInfoReq& a, GetMetaDirInfoReq& b); +}; + +template +uint32_t GetMetaDirInfoReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class VerifyClientVersionResp final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = VerifyClientVersionResp; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + VerifyClientVersionResp() : + code( ::nebula::cpp2::ErrorCode::SUCCEEDED) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + VerifyClientVersionResp(apache::thrift::FragileConstructor, ::nebula::cpp2::ErrorCode code__arg, nebula::HostAddr leader__arg, ::std::string error_msg__arg); + + VerifyClientVersionResp(VerifyClientVersionResp&&) = default; + + VerifyClientVersionResp(const VerifyClientVersionResp&) = default; + + + VerifyClientVersionResp& operator=(VerifyClientVersionResp&&) = default; + + VerifyClientVersionResp& operator=(const VerifyClientVersionResp&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::ErrorCode code; + private: + nebula::HostAddr leader; + private: + ::std::string error_msg; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool code; + bool leader; + bool error_msg; + } __isset = {}; + bool operator==(const VerifyClientVersionResp& rhs) const; +#ifndef SWIG + friend bool operator!=(const VerifyClientVersionResp& __x, const VerifyClientVersionResp& __y) { + return !(__x == __y); + } +#endif + bool operator<(const VerifyClientVersionResp& rhs) const; +#ifndef SWIG + friend bool operator>(const VerifyClientVersionResp& __x, const VerifyClientVersionResp& __y) { + return __y < __x; + } + friend bool operator<=(const VerifyClientVersionResp& __x, const VerifyClientVersionResp& __y) { + return !(__y < __x); + } + friend bool operator>=(const VerifyClientVersionResp& __x, const VerifyClientVersionResp& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() const& { + return {this->code, __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() const&& { + return {std::move(this->code), __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() & { + return {this->code, __isset.code}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref code_ref() && { + return {std::move(this->code), __isset.code}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() const& { + return {this->leader, __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() const&& { + return {std::move(this->leader), __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() & { + return {this->leader, __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref leader_ref() && { + return {std::move(this->leader), __isset.leader}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::optional_field_ref error_msg_ref() const& { + return {this->error_msg, __isset.error_msg}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref error_msg_ref() const&& { + return {std::move(this->error_msg), __isset.error_msg}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref error_msg_ref() & { + return {this->error_msg, __isset.error_msg}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref error_msg_ref() && { + return {std::move(this->error_msg), __isset.error_msg}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::ErrorCode get_code() const { + return code; + } + + ::nebula::cpp2::ErrorCode& set_code( ::nebula::cpp2::ErrorCode code_) { + code = code_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.code = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return code; + } + const nebula::HostAddr& get_leader() const&; + nebula::HostAddr get_leader() &&; + + template + nebula::HostAddr& set_leader(T_VerifyClientVersionResp_leader_struct_setter&& leader_) { + leader = std::forward(leader_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.leader = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return leader; + } + + const ::std::string* get_error_msg() const& { + return error_msg_ref() ? std::addressof(error_msg) : nullptr; + } + + ::std::string* get_error_msg() & { + return error_msg_ref() ? std::addressof(error_msg) : nullptr; + } + ::std::string* get_error_msg() && = delete; + + template + ::std::string& set_error_msg(T_VerifyClientVersionResp_error_msg_struct_setter&& error_msg_) { + error_msg = std::forward(error_msg_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.error_msg = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return error_msg; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< VerifyClientVersionResp >; + friend void swap(VerifyClientVersionResp& a, VerifyClientVersionResp& b); +}; + +template +uint32_t VerifyClientVersionResp::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { +class VerifyClientVersionReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = VerifyClientVersionReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + VerifyClientVersionReq() : + version(apache::thrift::StringTraits< std::string>::fromStringLiteral("2.6.0")) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + VerifyClientVersionReq(apache::thrift::FragileConstructor, ::std::string version__arg); + + VerifyClientVersionReq(VerifyClientVersionReq&&) = default; + + VerifyClientVersionReq(const VerifyClientVersionReq&) = default; + + + VerifyClientVersionReq& operator=(VerifyClientVersionReq&&) = default; + + VerifyClientVersionReq& operator=(const VerifyClientVersionReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + public: + ::std::string version; + + public: + bool operator==(const VerifyClientVersionReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const VerifyClientVersionReq& __x, const VerifyClientVersionReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const VerifyClientVersionReq& rhs) const; +#ifndef SWIG + friend bool operator>(const VerifyClientVersionReq& __x, const VerifyClientVersionReq& __y) { + return __y < __x; + } + friend bool operator<=(const VerifyClientVersionReq& __x, const VerifyClientVersionReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const VerifyClientVersionReq& __x, const VerifyClientVersionReq& __y) { + return !(__x < __y); + } +#endif + template + FOLLY_ERASE ::apache::thrift::required_field_ref version_ref() const& { + return ::apache::thrift::required_field_ref{this->version}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref version_ref() const&& { + return ::apache::thrift::required_field_ref{std::move(this->version)}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref version_ref() & { + return ::apache::thrift::required_field_ref{this->version}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref version_ref() && { + return ::apache::thrift::required_field_ref{std::move(this->version)}; + } + + const ::std::string& get_version() const& { + return version; + } + + ::std::string get_version() && { + return std::move(version); + } + + template + ::std::string& set_version(T_VerifyClientVersionReq_version_struct_setter&& version_) { + version = std::forward(version_); + return version; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< VerifyClientVersionReq >; + friend void swap(VerifyClientVersionReq& a, VerifyClientVersionReq& b); +}; + +template +uint32_t VerifyClientVersionReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::meta::cpp2 + +namespace apache { namespace thrift { + +template <> struct TEnumDataStorage<::nebula::meta::cpp2::ID::Type>; + +template <> struct TEnumTraits<::nebula::meta::cpp2::ID::Type> { + using type = ::nebula::meta::cpp2::ID::Type; + + static constexpr std::size_t const size = 5; + static folly::Range const values; + static folly::Range const names; + + static char const* findName(type value); + static bool findValue(char const* name, type* out); + +}; +}} // apache::thrift diff --git a/src/interface/gen-cpp2/meta_types.tcc b/src/interface/gen-cpp2/meta_types.tcc new file mode 100644 index 00000000..2b6e74ad --- /dev/null +++ b/src/interface/gen-cpp2/meta_types.tcc @@ -0,0 +1,28488 @@ +/** + * Autogenerated by Thrift for meta.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#pragma once + +#include "meta_types.h" + +#include + +namespace nebula { namespace meta { namespace cpp2 { + +}}} // nebula::meta::cpp2 +namespace std { + +} // std + +namespace nebula { namespace meta { namespace cpp2 { + +}}} // nebula::meta::cpp2 +namespace std { + +} // std + +namespace nebula { namespace meta { namespace cpp2 { + +}}} // nebula::meta::cpp2 +namespace std { + +} // std + +namespace nebula { namespace meta { namespace cpp2 { + +}}} // nebula::meta::cpp2 +namespace std { + +} // std + +namespace nebula { namespace meta { namespace cpp2 { + +}}} // nebula::meta::cpp2 +namespace std { + +} // std + +namespace nebula { namespace meta { namespace cpp2 { + +}}} // nebula::meta::cpp2 +namespace std { + +} // std + +namespace nebula { namespace meta { namespace cpp2 { + +}}} // nebula::meta::cpp2 +namespace std { + +} // std + +namespace nebula { namespace meta { namespace cpp2 { + +}}} // nebula::meta::cpp2 +namespace std { + +} // std + +namespace nebula { namespace meta { namespace cpp2 { + +}}} // nebula::meta::cpp2 +namespace std { + +} // std + +namespace nebula { namespace meta { namespace cpp2 { + +}}} // nebula::meta::cpp2 +namespace std { + +} // std + +namespace nebula { namespace meta { namespace cpp2 { + +}}} // nebula::meta::cpp2 +namespace std { + +} // std + +namespace nebula { namespace meta { namespace cpp2 { + +}}} // nebula::meta::cpp2 +namespace std { + +} // std + +namespace nebula { namespace meta { namespace cpp2 { + +}}} // nebula::meta::cpp2 +namespace std { + +} // std + +namespace nebula { namespace meta { namespace cpp2 { + +}}} // nebula::meta::cpp2 +namespace std { + +} // std + +namespace nebula { namespace meta { namespace cpp2 { + +}}} // nebula::meta::cpp2 +namespace std { + +} // std + +namespace nebula { namespace meta { namespace cpp2 { + +}}} // nebula::meta::cpp2 +namespace std { + +} // std + +namespace nebula { namespace meta { namespace cpp2 { + +}}} // nebula::meta::cpp2 +namespace std { + +} // std + +namespace nebula { namespace meta { namespace cpp2 { + +}}} // nebula::meta::cpp2 +namespace std { + +} // std + + +namespace apache { +namespace thrift { +namespace detail { + +template <> +struct TccStructTraits<::nebula::meta::cpp2::ID> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::ColumnTypeDef> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::ColumnDef> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::SchemaProp> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::Schema> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::IdName> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::SpaceDesc> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::SpaceItem> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::TagItem> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::AlterSchemaItem> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::EdgeItem> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::IndexItem> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::HostItem> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::UserItem> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::RoleItem> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::ExecResp> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::AdminJobReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::JobDesc> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::TaskDesc> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::AdminJobResult> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::AdminJobResp> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::Correlativity> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::StatsItem> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::CreateSpaceReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::CreateSpaceAsReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::DropSpaceReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::ListSpacesReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::ListSpacesResp> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::GetSpaceReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::GetSpaceResp> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::CreateTagReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::AlterTagReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::DropTagReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::ListTagsReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::ListTagsResp> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::GetTagReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::GetTagResp> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::CreateEdgeReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::AlterEdgeReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::GetEdgeReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::GetEdgeResp> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::DropEdgeReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::ListEdgesReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::ListEdgesResp> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::ListHostsReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::ListHostsResp> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::PartItem> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::ListPartsReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::ListPartsResp> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::GetPartsAllocReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::GetPartsAllocResp> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::MultiPutReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::GetReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::GetResp> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::MultiGetReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::MultiGetResp> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::RemoveReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::RemoveRangeReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::ScanReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::ScanResp> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::HBResp> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::LeaderInfo> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::HBReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::IndexFieldDef> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::CreateTagIndexReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::DropTagIndexReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::GetTagIndexReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::GetTagIndexResp> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::ListTagIndexesReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::ListTagIndexesResp> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::CreateEdgeIndexReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::DropEdgeIndexReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::GetEdgeIndexReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::GetEdgeIndexResp> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::ListEdgeIndexesReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::ListEdgeIndexesResp> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::RebuildIndexReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::CreateUserReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::DropUserReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::AlterUserReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::GrantRoleReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::RevokeRoleReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::ListUsersReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::ListUsersResp> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::ListRolesReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::ListRolesResp> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::GetUserRolesReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::ChangePasswordReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::BalanceReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::BalanceTask> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::BalanceResp> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::LeaderBalanceReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::ConfigItem> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::RegConfigReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::GetConfigReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::GetConfigResp> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::SetConfigReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::ListConfigsReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::ListConfigsResp> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::CreateSnapshotReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::DropSnapshotReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::ListSnapshotsReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::Snapshot> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::ListSnapshotsResp> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::ListIndexStatusReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::IndexStatus> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::ListIndexStatusResp> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::AddZoneReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::DropZoneReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::AddHostIntoZoneReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::DropHostFromZoneReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::GetZoneReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::GetZoneResp> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::ListZonesReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::Zone> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::ListZonesResp> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::AddGroupReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::DropGroupReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::AddZoneIntoGroupReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::DropZoneFromGroupReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::GetGroupReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::GetGroupResp> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::ListGroupsReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::Group> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::ListGroupsResp> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::AddListenerReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::RemoveListenerReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::ListListenerReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::ListenerInfo> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::ListListenerResp> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::GetStatsReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::GetStatsResp> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::BackupInfo> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::SpaceBackupInfo> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::BackupMeta> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::CreateBackupReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::CreateBackupResp> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::HostPair> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::RestoreMetaReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::FTClient> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::SignInFTServiceReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::SignOutFTServiceReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::ListFTClientsReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::ListFTClientsResp> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::FTIndex> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::CreateFTIndexReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::DropFTIndexReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::ListFTIndexesReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::ListFTIndexesResp> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::QueryDesc> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::Session> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::CreateSessionReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::CreateSessionResp> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::UpdateSessionsReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::UpdateSessionsResp> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::ListSessionsReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::ListSessionsResp> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::GetSessionReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::GetSessionResp> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::RemoveSessionReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::KillQueryReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::ReportTaskReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::ListClusterInfoResp> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::ListClusterInfoReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::GetMetaDirInfoResp> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::GetMetaDirInfoReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::VerifyClientVersionResp> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::meta::cpp2::VerifyClientVersionReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace meta { namespace cpp2 { + +template +void ID::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + _readState.fieldId = 0; + + _readState.readStructBegin(iprot); + + _readState.readFieldBegin(iprot); + if (_readState.atStop()) { + this->__clear(); + } else { + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + switch (_readState.fieldId) { + case 1: + { + if (_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32)) { + this->set_space_id(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::readWithContext(*iprot, this->mutable_space_id(), _readState); + } else { + _readState.skip(iprot); + } + break; + } + case 2: + { + if (_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32)) { + this->set_tag_id(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::TagID>::readWithContext(*iprot, this->mutable_tag_id(), _readState); + } else { + _readState.skip(iprot); + } + break; + } + case 3: + { + if (_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32)) { + this->set_edge_type(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::EdgeType>::readWithContext(*iprot, this->mutable_edge_type(), _readState); + } else { + _readState.skip(iprot); + } + break; + } + case 4: + { + if (_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32)) { + this->set_index_id(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::IndexID>::readWithContext(*iprot, this->mutable_index_id(), _readState); + } else { + _readState.skip(iprot); + } + break; + } + case 5: + { + if (_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I64)) { + this->set_cluster_id(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::meta::cpp2::ClusterID>::readWithContext(*iprot, this->mutable_cluster_id(), _readState); + } else { + _readState.skip(iprot); + } + break; + } + default: + { + _readState.skip(iprot); + break; + } + } + _readState.readFieldEnd(iprot); + _readState.readFieldBegin(iprot); + if (UNLIKELY(!_readState.atStop())) { + using apache::thrift::protocol::TProtocolException; + TProtocolException::throwUnionMissingStop(); + } + } + _readState.readStructEnd(iprot); +} +template +uint32_t ID::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ID"); + switch(this->getType()) { + case ID::Type::space_id: + { + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->get_space_id()); + break; + } + case ID::Type::tag_id: + { + xfer += prot_->serializedFieldSize("tag_id", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::TagID>::serializedSize(*prot_, this->get_tag_id()); + break; + } + case ID::Type::edge_type: + { + xfer += prot_->serializedFieldSize("edge_type", apache::thrift::protocol::T_I32, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::EdgeType>::serializedSize(*prot_, this->get_edge_type()); + break; + } + case ID::Type::index_id: + { + xfer += prot_->serializedFieldSize("index_id", apache::thrift::protocol::T_I32, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::IndexID>::serializedSize(*prot_, this->get_index_id()); + break; + } + case ID::Type::cluster_id: + { + xfer += prot_->serializedFieldSize("cluster_id", apache::thrift::protocol::T_I64, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::meta::cpp2::ClusterID>::serializedSize(*prot_, this->get_cluster_id()); + break; + } + case ID::Type::__EMPTY__:; + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ID::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ID"); + switch(this->getType()) { + case ID::Type::space_id: + { + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->get_space_id()); + break; + } + case ID::Type::tag_id: + { + xfer += prot_->serializedFieldSize("tag_id", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::TagID>::serializedSize(*prot_, this->get_tag_id()); + break; + } + case ID::Type::edge_type: + { + xfer += prot_->serializedFieldSize("edge_type", apache::thrift::protocol::T_I32, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::EdgeType>::serializedSize(*prot_, this->get_edge_type()); + break; + } + case ID::Type::index_id: + { + xfer += prot_->serializedFieldSize("index_id", apache::thrift::protocol::T_I32, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::IndexID>::serializedSize(*prot_, this->get_index_id()); + break; + } + case ID::Type::cluster_id: + { + xfer += prot_->serializedFieldSize("cluster_id", apache::thrift::protocol::T_I64, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::meta::cpp2::ClusterID>::serializedSize(*prot_, this->get_cluster_id()); + break; + } + case ID::Type::__EMPTY__:; + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ID::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("ID"); + switch(this->getType()) { + case ID::Type::space_id: + { + xfer += prot_->writeFieldBegin("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::write(*prot_, this->get_space_id()); + xfer += prot_->writeFieldEnd(); + break; + } + case ID::Type::tag_id: + { + xfer += prot_->writeFieldBegin("tag_id", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::TagID>::write(*prot_, this->get_tag_id()); + xfer += prot_->writeFieldEnd(); + break; + } + case ID::Type::edge_type: + { + xfer += prot_->writeFieldBegin("edge_type", apache::thrift::protocol::T_I32, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::EdgeType>::write(*prot_, this->get_edge_type()); + xfer += prot_->writeFieldEnd(); + break; + } + case ID::Type::index_id: + { + xfer += prot_->writeFieldBegin("index_id", apache::thrift::protocol::T_I32, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::IndexID>::write(*prot_, this->get_index_id()); + xfer += prot_->writeFieldEnd(); + break; + } + case ID::Type::cluster_id: + { + xfer += prot_->writeFieldBegin("cluster_id", apache::thrift::protocol::T_I64, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::meta::cpp2::ClusterID>::write(*prot_, this->get_cluster_id()); + xfer += prot_->writeFieldEnd(); + break; + } + case ID::Type::__EMPTY__:; + } + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void ID::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t ID::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t ID::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t ID::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void ID::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t ID::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t ID::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t ID::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void ColumnTypeDef::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_type: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::PropertyType>::readWithContext(*iprot, this->type, _readState); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_I16))) { + goto _loop; + } +_readField_type_length: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int16_t>::readWithContext(*iprot, this->type_length, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.type_length = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_geo_shape: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::GeoShape>::readWithContext(*iprot, this->geo_shape, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.geo_shape = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_type; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I16))) { + goto _readField_type_length; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_geo_shape; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t ColumnTypeDef::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ColumnTypeDef"); + xfer += prot_->serializedFieldSize("type", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::PropertyType>::serializedSize(*prot_, this->type); + if (this->type_length_ref().has_value()) { + xfer += prot_->serializedFieldSize("type_length", apache::thrift::protocol::T_I16, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int16_t>::serializedSize(*prot_, this->type_length); + } + if (this->geo_shape_ref().has_value()) { + xfer += prot_->serializedFieldSize("geo_shape", apache::thrift::protocol::T_I32, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::GeoShape>::serializedSize(*prot_, this->geo_shape); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ColumnTypeDef::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ColumnTypeDef"); + xfer += prot_->serializedFieldSize("type", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::PropertyType>::serializedSize(*prot_, this->type); + if (this->type_length_ref().has_value()) { + xfer += prot_->serializedFieldSize("type_length", apache::thrift::protocol::T_I16, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int16_t>::serializedSize(*prot_, this->type_length); + } + if (this->geo_shape_ref().has_value()) { + xfer += prot_->serializedFieldSize("geo_shape", apache::thrift::protocol::T_I32, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::GeoShape>::serializedSize(*prot_, this->geo_shape); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ColumnTypeDef::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("ColumnTypeDef"); + xfer += prot_->writeFieldBegin("type", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::PropertyType>::write(*prot_, this->type); + xfer += prot_->writeFieldEnd(); + if (this->type_length_ref().has_value()) { + xfer += prot_->writeFieldBegin("type_length", apache::thrift::protocol::T_I16, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int16_t>::write(*prot_, this->type_length); + xfer += prot_->writeFieldEnd(); + } + if (this->geo_shape_ref().has_value()) { + xfer += prot_->writeFieldBegin("geo_shape", apache::thrift::protocol::T_I32, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::GeoShape>::write(*prot_, this->geo_shape); + xfer += prot_->writeFieldEnd(); + } + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void ColumnTypeDef::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t ColumnTypeDef::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t ColumnTypeDef::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t ColumnTypeDef::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void ColumnTypeDef::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t ColumnTypeDef::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t ColumnTypeDef::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t ColumnTypeDef::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void ColumnDef::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_name: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->name, _readState); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_type: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::ColumnTypeDef>::readWithContext(*iprot, this->type, _readState); + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_default_value: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->default_value, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.default_value = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 4, + apache::thrift::protocol::T_BOOL))) { + goto _loop; + } +_readField_nullable: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::readWithContext(*iprot, this->nullable, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.nullable = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 4, + 5, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_comment: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->comment, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.comment = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 5, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_name; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_type; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_default_value; + } else { + goto _skip; + } + } + case 4: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_BOOL))) { + goto _readField_nullable; + } else { + goto _skip; + } + } + case 5: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_comment; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t ColumnDef::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ColumnDef"); + xfer += prot_->serializedFieldSize("name", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->name); + xfer += prot_->serializedFieldSize("type", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::ColumnTypeDef>::serializedSize(*prot_, this->type); + if (this->default_value_ref().has_value()) { + xfer += prot_->serializedFieldSize("default_value", apache::thrift::protocol::T_STRING, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->default_value); + } + if (this->nullable_ref().has_value()) { + xfer += prot_->serializedFieldSize("nullable", apache::thrift::protocol::T_BOOL, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::serializedSize(*prot_, this->nullable); + } + if (this->comment_ref().has_value()) { + xfer += prot_->serializedFieldSize("comment", apache::thrift::protocol::T_STRING, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->comment); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ColumnDef::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ColumnDef"); + xfer += prot_->serializedFieldSize("name", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->name); + xfer += prot_->serializedFieldSize("type", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::ColumnTypeDef>::serializedSize(*prot_, this->type); + if (this->default_value_ref().has_value()) { + xfer += prot_->serializedFieldSize("default_value", apache::thrift::protocol::T_STRING, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->default_value); + } + if (this->nullable_ref().has_value()) { + xfer += prot_->serializedFieldSize("nullable", apache::thrift::protocol::T_BOOL, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::serializedSize(*prot_, this->nullable); + } + if (this->comment_ref().has_value()) { + xfer += prot_->serializedFieldSize("comment", apache::thrift::protocol::T_STRING, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->comment); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ColumnDef::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("ColumnDef"); + xfer += prot_->writeFieldBegin("name", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->name); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("type", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::ColumnTypeDef>::write(*prot_, this->type); + xfer += prot_->writeFieldEnd(); + if (this->default_value_ref().has_value()) { + xfer += prot_->writeFieldBegin("default_value", apache::thrift::protocol::T_STRING, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->default_value); + xfer += prot_->writeFieldEnd(); + } + if (this->nullable_ref().has_value()) { + xfer += prot_->writeFieldBegin("nullable", apache::thrift::protocol::T_BOOL, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::write(*prot_, this->nullable); + xfer += prot_->writeFieldEnd(); + } + if (this->comment_ref().has_value()) { + xfer += prot_->writeFieldBegin("comment", apache::thrift::protocol::T_STRING, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->comment); + xfer += prot_->writeFieldEnd(); + } + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void ColumnDef::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t ColumnDef::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t ColumnDef::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t ColumnDef::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void ColumnDef::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t ColumnDef::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t ColumnDef::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t ColumnDef::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void SchemaProp::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I64))) { + goto _loop; + } +_readField_ttl_duration: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::readWithContext(*iprot, this->ttl_duration, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.ttl_duration = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_ttl_col: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->ttl_col, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.ttl_col = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_comment: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->comment, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.comment = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I64))) { + goto _readField_ttl_duration; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_ttl_col; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_comment; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t SchemaProp::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("SchemaProp"); + if (this->ttl_duration_ref().has_value()) { + xfer += prot_->serializedFieldSize("ttl_duration", apache::thrift::protocol::T_I64, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::serializedSize(*prot_, this->ttl_duration); + } + if (this->ttl_col_ref().has_value()) { + xfer += prot_->serializedFieldSize("ttl_col", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->ttl_col); + } + if (this->comment_ref().has_value()) { + xfer += prot_->serializedFieldSize("comment", apache::thrift::protocol::T_STRING, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->comment); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t SchemaProp::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("SchemaProp"); + if (this->ttl_duration_ref().has_value()) { + xfer += prot_->serializedFieldSize("ttl_duration", apache::thrift::protocol::T_I64, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::serializedSize(*prot_, this->ttl_duration); + } + if (this->ttl_col_ref().has_value()) { + xfer += prot_->serializedFieldSize("ttl_col", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->ttl_col); + } + if (this->comment_ref().has_value()) { + xfer += prot_->serializedFieldSize("comment", apache::thrift::protocol::T_STRING, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->comment); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t SchemaProp::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("SchemaProp"); + if (this->ttl_duration_ref().has_value()) { + xfer += prot_->writeFieldBegin("ttl_duration", apache::thrift::protocol::T_I64, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::write(*prot_, this->ttl_duration); + xfer += prot_->writeFieldEnd(); + } + if (this->ttl_col_ref().has_value()) { + xfer += prot_->writeFieldBegin("ttl_col", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->ttl_col); + xfer += prot_->writeFieldEnd(); + } + if (this->comment_ref().has_value()) { + xfer += prot_->writeFieldBegin("comment", apache::thrift::protocol::T_STRING, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->comment); + xfer += prot_->writeFieldEnd(); + } + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void SchemaProp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t SchemaProp::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t SchemaProp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t SchemaProp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void SchemaProp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t SchemaProp::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t SchemaProp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t SchemaProp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void Schema::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_columns: + { + _readState.beforeSubobject(iprot); + this->columns = ::std::vector< ::nebula::meta::cpp2::ColumnDef>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::ColumnDef>>::readWithContext(*iprot, this->columns, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.columns = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_schema_prop: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::SchemaProp>::readWithContext(*iprot, this->schema_prop, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.schema_prop = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_columns; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_schema_prop; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t Schema::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("Schema"); + xfer += prot_->serializedFieldSize("columns", apache::thrift::protocol::T_LIST, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::ColumnDef>>::serializedSize(*prot_, this->columns); + xfer += prot_->serializedFieldSize("schema_prop", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::SchemaProp>::serializedSize(*prot_, this->schema_prop); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t Schema::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("Schema"); + xfer += prot_->serializedFieldSize("columns", apache::thrift::protocol::T_LIST, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::ColumnDef>>::serializedSize(*prot_, this->columns); + xfer += prot_->serializedFieldSize("schema_prop", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::SchemaProp>::serializedSize(*prot_, this->schema_prop); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t Schema::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("Schema"); + xfer += prot_->writeFieldBegin("columns", apache::thrift::protocol::T_LIST, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::ColumnDef>>::write(*prot_, this->columns); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("schema_prop", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::SchemaProp>::write(*prot_, this->schema_prop); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void Schema::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t Schema::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t Schema::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t Schema::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void Schema::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t Schema::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t Schema::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t Schema::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void IdName::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_id: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::variant, ::nebula::meta::cpp2::ID>::readWithContext(*iprot, this->id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_name: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->name, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.name = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_id; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_name; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t IdName::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("IdName"); + xfer += prot_->serializedFieldSize("id", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::variant, ::nebula::meta::cpp2::ID>::serializedSize(*prot_, this->id); + xfer += prot_->serializedFieldSize("name", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->name); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t IdName::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("IdName"); + xfer += prot_->serializedFieldSize("id", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::variant, ::nebula::meta::cpp2::ID>::serializedSize(*prot_, this->id); + xfer += prot_->serializedFieldSize("name", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->name); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t IdName::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("IdName"); + xfer += prot_->writeFieldBegin("id", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::variant, ::nebula::meta::cpp2::ID>::write(*prot_, this->id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("name", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->name); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void IdName::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t IdName::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t IdName::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t IdName::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void IdName::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t IdName::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t IdName::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t IdName::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void SpaceDesc::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_space_name: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->space_name, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.space_name = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_partition_num: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::readWithContext(*iprot, this->partition_num, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.partition_num = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_replica_factor: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::readWithContext(*iprot, this->replica_factor, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.replica_factor = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 4, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_charset_name: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->charset_name, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.charset_name = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 4, + 5, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_collate_name: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->collate_name, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.collate_name = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 5, + 6, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_vid_type: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::ColumnTypeDef>::readWithContext(*iprot, this->vid_type, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.vid_type = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 6, + 7, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_group_name: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->group_name, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.group_name = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 7, + 8, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_isolation_level: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::IsolationLevel>::readWithContext(*iprot, this->isolation_level, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.isolation_level = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 8, + 9, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_comment: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->comment, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.comment = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 9, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_space_name; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_partition_num; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_replica_factor; + } else { + goto _skip; + } + } + case 4: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_charset_name; + } else { + goto _skip; + } + } + case 5: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_collate_name; + } else { + goto _skip; + } + } + case 6: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_vid_type; + } else { + goto _skip; + } + } + case 7: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_group_name; + } else { + goto _skip; + } + } + case 8: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_isolation_level; + } else { + goto _skip; + } + } + case 9: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_comment; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t SpaceDesc::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("SpaceDesc"); + xfer += prot_->serializedFieldSize("space_name", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->space_name); + xfer += prot_->serializedFieldSize("partition_num", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::serializedSize(*prot_, this->partition_num); + xfer += prot_->serializedFieldSize("replica_factor", apache::thrift::protocol::T_I32, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::serializedSize(*prot_, this->replica_factor); + xfer += prot_->serializedFieldSize("charset_name", apache::thrift::protocol::T_STRING, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->charset_name); + xfer += prot_->serializedFieldSize("collate_name", apache::thrift::protocol::T_STRING, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->collate_name); + xfer += prot_->serializedFieldSize("vid_type", apache::thrift::protocol::T_STRUCT, 6); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::ColumnTypeDef>::serializedSize(*prot_, this->vid_type); + if (this->group_name_ref().has_value()) { + xfer += prot_->serializedFieldSize("group_name", apache::thrift::protocol::T_STRING, 7); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->group_name); + } + if (this->isolation_level_ref().has_value()) { + xfer += prot_->serializedFieldSize("isolation_level", apache::thrift::protocol::T_I32, 8); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::IsolationLevel>::serializedSize(*prot_, this->isolation_level); + } + if (this->comment_ref().has_value()) { + xfer += prot_->serializedFieldSize("comment", apache::thrift::protocol::T_STRING, 9); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->comment); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t SpaceDesc::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("SpaceDesc"); + xfer += prot_->serializedFieldSize("space_name", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->space_name); + xfer += prot_->serializedFieldSize("partition_num", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::serializedSize(*prot_, this->partition_num); + xfer += prot_->serializedFieldSize("replica_factor", apache::thrift::protocol::T_I32, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::serializedSize(*prot_, this->replica_factor); + xfer += prot_->serializedFieldSize("charset_name", apache::thrift::protocol::T_STRING, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->charset_name); + xfer += prot_->serializedFieldSize("collate_name", apache::thrift::protocol::T_STRING, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->collate_name); + xfer += prot_->serializedFieldSize("vid_type", apache::thrift::protocol::T_STRUCT, 6); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::ColumnTypeDef>::serializedSize(*prot_, this->vid_type); + if (this->group_name_ref().has_value()) { + xfer += prot_->serializedFieldSize("group_name", apache::thrift::protocol::T_STRING, 7); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->group_name); + } + if (this->isolation_level_ref().has_value()) { + xfer += prot_->serializedFieldSize("isolation_level", apache::thrift::protocol::T_I32, 8); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::IsolationLevel>::serializedSize(*prot_, this->isolation_level); + } + if (this->comment_ref().has_value()) { + xfer += prot_->serializedFieldSize("comment", apache::thrift::protocol::T_STRING, 9); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->comment); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t SpaceDesc::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("SpaceDesc"); + xfer += prot_->writeFieldBegin("space_name", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->space_name); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("partition_num", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::write(*prot_, this->partition_num); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("replica_factor", apache::thrift::protocol::T_I32, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::write(*prot_, this->replica_factor); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("charset_name", apache::thrift::protocol::T_STRING, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->charset_name); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("collate_name", apache::thrift::protocol::T_STRING, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->collate_name); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("vid_type", apache::thrift::protocol::T_STRUCT, 6); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::ColumnTypeDef>::write(*prot_, this->vid_type); + xfer += prot_->writeFieldEnd(); + if (this->group_name_ref().has_value()) { + xfer += prot_->writeFieldBegin("group_name", apache::thrift::protocol::T_STRING, 7); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->group_name); + xfer += prot_->writeFieldEnd(); + } + if (this->isolation_level_ref().has_value()) { + xfer += prot_->writeFieldBegin("isolation_level", apache::thrift::protocol::T_I32, 8); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::IsolationLevel>::write(*prot_, this->isolation_level); + xfer += prot_->writeFieldEnd(); + } + if (this->comment_ref().has_value()) { + xfer += prot_->writeFieldBegin("comment", apache::thrift::protocol::T_STRING, 9); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->comment); + xfer += prot_->writeFieldEnd(); + } + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void SpaceDesc::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t SpaceDesc::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t SpaceDesc::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t SpaceDesc::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void SpaceDesc::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t SpaceDesc::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t SpaceDesc::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t SpaceDesc::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void SpaceItem::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_space_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::readWithContext(*iprot, this->space_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.space_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_properties: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::SpaceDesc>::readWithContext(*iprot, this->properties, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.properties = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_space_id; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_properties; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t SpaceItem::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("SpaceItem"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("properties", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::SpaceDesc>::serializedSize(*prot_, this->properties); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t SpaceItem::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("SpaceItem"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("properties", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::SpaceDesc>::serializedSize(*prot_, this->properties); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t SpaceItem::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("SpaceItem"); + xfer += prot_->writeFieldBegin("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::write(*prot_, this->space_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("properties", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::SpaceDesc>::write(*prot_, this->properties); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void SpaceItem::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t SpaceItem::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t SpaceItem::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t SpaceItem::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void SpaceItem::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t SpaceItem::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t SpaceItem::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t SpaceItem::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void TagItem::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_tag_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::TagID>::readWithContext(*iprot, this->tag_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.tag_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_tag_name: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->tag_name, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.tag_name = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_I64))) { + goto _loop; + } +_readField_version: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::meta::cpp2::SchemaVer>::readWithContext(*iprot, this->version, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.version = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 4, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_schema: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::Schema>::readWithContext(*iprot, this->schema, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.schema = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 4, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_tag_id; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_tag_name; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I64))) { + goto _readField_version; + } else { + goto _skip; + } + } + case 4: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_schema; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t TagItem::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("TagItem"); + xfer += prot_->serializedFieldSize("tag_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::TagID>::serializedSize(*prot_, this->tag_id); + xfer += prot_->serializedFieldSize("tag_name", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->tag_name); + xfer += prot_->serializedFieldSize("version", apache::thrift::protocol::T_I64, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::meta::cpp2::SchemaVer>::serializedSize(*prot_, this->version); + xfer += prot_->serializedFieldSize("schema", apache::thrift::protocol::T_STRUCT, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::Schema>::serializedSize(*prot_, this->schema); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t TagItem::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("TagItem"); + xfer += prot_->serializedFieldSize("tag_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::TagID>::serializedSize(*prot_, this->tag_id); + xfer += prot_->serializedFieldSize("tag_name", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->tag_name); + xfer += prot_->serializedFieldSize("version", apache::thrift::protocol::T_I64, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::meta::cpp2::SchemaVer>::serializedSize(*prot_, this->version); + xfer += prot_->serializedFieldSize("schema", apache::thrift::protocol::T_STRUCT, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::Schema>::serializedSize(*prot_, this->schema); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t TagItem::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("TagItem"); + xfer += prot_->writeFieldBegin("tag_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::TagID>::write(*prot_, this->tag_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("tag_name", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->tag_name); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("version", apache::thrift::protocol::T_I64, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::meta::cpp2::SchemaVer>::write(*prot_, this->version); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("schema", apache::thrift::protocol::T_STRUCT, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::Schema>::write(*prot_, this->schema); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void TagItem::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t TagItem::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t TagItem::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t TagItem::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void TagItem::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t TagItem::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t TagItem::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t TagItem::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void AlterSchemaItem::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_op: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::AlterSchemaOp>::readWithContext(*iprot, this->op, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.op = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_schema: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::Schema>::readWithContext(*iprot, this->schema, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.schema = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_op; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_schema; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t AlterSchemaItem::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("AlterSchemaItem"); + xfer += prot_->serializedFieldSize("op", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::AlterSchemaOp>::serializedSize(*prot_, this->op); + xfer += prot_->serializedFieldSize("schema", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::Schema>::serializedSize(*prot_, this->schema); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t AlterSchemaItem::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("AlterSchemaItem"); + xfer += prot_->serializedFieldSize("op", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::AlterSchemaOp>::serializedSize(*prot_, this->op); + xfer += prot_->serializedFieldSize("schema", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::Schema>::serializedSize(*prot_, this->schema); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t AlterSchemaItem::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("AlterSchemaItem"); + xfer += prot_->writeFieldBegin("op", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::AlterSchemaOp>::write(*prot_, this->op); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("schema", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::Schema>::write(*prot_, this->schema); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void AlterSchemaItem::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t AlterSchemaItem::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t AlterSchemaItem::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t AlterSchemaItem::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void AlterSchemaItem::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t AlterSchemaItem::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t AlterSchemaItem::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t AlterSchemaItem::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void EdgeItem::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_edge_type: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::EdgeType>::readWithContext(*iprot, this->edge_type, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.edge_type = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_edge_name: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->edge_name, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.edge_name = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_I64))) { + goto _loop; + } +_readField_version: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::meta::cpp2::SchemaVer>::readWithContext(*iprot, this->version, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.version = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 4, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_schema: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::Schema>::readWithContext(*iprot, this->schema, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.schema = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 4, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_edge_type; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_edge_name; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I64))) { + goto _readField_version; + } else { + goto _skip; + } + } + case 4: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_schema; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t EdgeItem::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("EdgeItem"); + xfer += prot_->serializedFieldSize("edge_type", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::EdgeType>::serializedSize(*prot_, this->edge_type); + xfer += prot_->serializedFieldSize("edge_name", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->edge_name); + xfer += prot_->serializedFieldSize("version", apache::thrift::protocol::T_I64, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::meta::cpp2::SchemaVer>::serializedSize(*prot_, this->version); + xfer += prot_->serializedFieldSize("schema", apache::thrift::protocol::T_STRUCT, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::Schema>::serializedSize(*prot_, this->schema); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t EdgeItem::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("EdgeItem"); + xfer += prot_->serializedFieldSize("edge_type", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::EdgeType>::serializedSize(*prot_, this->edge_type); + xfer += prot_->serializedFieldSize("edge_name", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->edge_name); + xfer += prot_->serializedFieldSize("version", apache::thrift::protocol::T_I64, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::meta::cpp2::SchemaVer>::serializedSize(*prot_, this->version); + xfer += prot_->serializedFieldSize("schema", apache::thrift::protocol::T_STRUCT, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::Schema>::serializedSize(*prot_, this->schema); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t EdgeItem::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("EdgeItem"); + xfer += prot_->writeFieldBegin("edge_type", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::EdgeType>::write(*prot_, this->edge_type); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("edge_name", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->edge_name); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("version", apache::thrift::protocol::T_I64, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::meta::cpp2::SchemaVer>::write(*prot_, this->version); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("schema", apache::thrift::protocol::T_STRUCT, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::Schema>::write(*prot_, this->schema); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void EdgeItem::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t EdgeItem::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t EdgeItem::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t EdgeItem::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void EdgeItem::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t EdgeItem::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t EdgeItem::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t EdgeItem::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void IndexItem::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_index_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::IndexID>::readWithContext(*iprot, this->index_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.index_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_index_name: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->index_name, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.index_name = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_schema_id: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::variant, ::nebula::cpp2::SchemaID>::readWithContext(*iprot, this->schema_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.schema_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 4, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_schema_name: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->schema_name, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.schema_name = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 4, + 5, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_fields: + { + _readState.beforeSubobject(iprot); + this->fields = ::std::vector< ::nebula::meta::cpp2::ColumnDef>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::ColumnDef>>::readWithContext(*iprot, this->fields, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.fields = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 5, + 6, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_comment: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->comment, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.comment = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 6, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_index_id; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_index_name; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_schema_id; + } else { + goto _skip; + } + } + case 4: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_schema_name; + } else { + goto _skip; + } + } + case 5: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_fields; + } else { + goto _skip; + } + } + case 6: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_comment; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t IndexItem::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("IndexItem"); + xfer += prot_->serializedFieldSize("index_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::IndexID>::serializedSize(*prot_, this->index_id); + xfer += prot_->serializedFieldSize("index_name", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->index_name); + xfer += prot_->serializedFieldSize("schema_id", apache::thrift::protocol::T_STRUCT, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::variant, ::nebula::cpp2::SchemaID>::serializedSize(*prot_, this->schema_id); + xfer += prot_->serializedFieldSize("schema_name", apache::thrift::protocol::T_STRING, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->schema_name); + xfer += prot_->serializedFieldSize("fields", apache::thrift::protocol::T_LIST, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::ColumnDef>>::serializedSize(*prot_, this->fields); + if (this->comment_ref().has_value()) { + xfer += prot_->serializedFieldSize("comment", apache::thrift::protocol::T_STRING, 6); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->comment); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t IndexItem::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("IndexItem"); + xfer += prot_->serializedFieldSize("index_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::IndexID>::serializedSize(*prot_, this->index_id); + xfer += prot_->serializedFieldSize("index_name", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->index_name); + xfer += prot_->serializedFieldSize("schema_id", apache::thrift::protocol::T_STRUCT, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::variant, ::nebula::cpp2::SchemaID>::serializedSize(*prot_, this->schema_id); + xfer += prot_->serializedFieldSize("schema_name", apache::thrift::protocol::T_STRING, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->schema_name); + xfer += prot_->serializedFieldSize("fields", apache::thrift::protocol::T_LIST, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::ColumnDef>>::serializedSize(*prot_, this->fields); + if (this->comment_ref().has_value()) { + xfer += prot_->serializedFieldSize("comment", apache::thrift::protocol::T_STRING, 6); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->comment); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t IndexItem::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("IndexItem"); + xfer += prot_->writeFieldBegin("index_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::IndexID>::write(*prot_, this->index_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("index_name", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->index_name); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("schema_id", apache::thrift::protocol::T_STRUCT, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::variant, ::nebula::cpp2::SchemaID>::write(*prot_, this->schema_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("schema_name", apache::thrift::protocol::T_STRING, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->schema_name); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("fields", apache::thrift::protocol::T_LIST, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::ColumnDef>>::write(*prot_, this->fields); + xfer += prot_->writeFieldEnd(); + if (this->comment_ref().has_value()) { + xfer += prot_->writeFieldBegin("comment", apache::thrift::protocol::T_STRING, 6); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->comment); + xfer += prot_->writeFieldEnd(); + } + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void IndexItem::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t IndexItem::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t IndexItem::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t IndexItem::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void IndexItem::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t IndexItem::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t IndexItem::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t IndexItem::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void HostItem::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_hostAddr: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::readWithContext(*iprot, this->hostAddr, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.hostAddr = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_status: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::HostStatus>::readWithContext(*iprot, this->status, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.status = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_MAP))) { + goto _loop; + } +_readField_leader_parts: + { + _readState.beforeSubobject(iprot); + this->leader_parts = std::unordered_map<::std::string, ::std::vector< ::nebula::cpp2::PartitionID>>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::binary, ::apache::thrift::type_class::list<::apache::thrift::type_class::integral>>, std::unordered_map<::std::string, ::std::vector< ::nebula::cpp2::PartitionID>>>::readWithContext(*iprot, this->leader_parts, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.leader_parts = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 4, + apache::thrift::protocol::T_MAP))) { + goto _loop; + } +_readField_all_parts: + { + _readState.beforeSubobject(iprot); + this->all_parts = std::unordered_map<::std::string, ::std::vector< ::nebula::cpp2::PartitionID>>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::binary, ::apache::thrift::type_class::list<::apache::thrift::type_class::integral>>, std::unordered_map<::std::string, ::std::vector< ::nebula::cpp2::PartitionID>>>::readWithContext(*iprot, this->all_parts, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.all_parts = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 4, + 5, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_role: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::HostRole>::readWithContext(*iprot, this->role, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.role = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 5, + 6, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_git_info_sha: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->git_info_sha, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.git_info_sha = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 6, + 7, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_zone_name: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->zone_name, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.zone_name = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 7, + 8, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_version: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->version, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.version = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 8, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_hostAddr; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_status; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_MAP))) { + goto _readField_leader_parts; + } else { + goto _skip; + } + } + case 4: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_MAP))) { + goto _readField_all_parts; + } else { + goto _skip; + } + } + case 5: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_role; + } else { + goto _skip; + } + } + case 6: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_git_info_sha; + } else { + goto _skip; + } + } + case 7: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_zone_name; + } else { + goto _skip; + } + } + case 8: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_version; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t HostItem::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("HostItem"); + xfer += prot_->serializedFieldSize("hostAddr", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->hostAddr); + xfer += prot_->serializedFieldSize("status", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::HostStatus>::serializedSize(*prot_, this->status); + xfer += prot_->serializedFieldSize("leader_parts", apache::thrift::protocol::T_MAP, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::binary, ::apache::thrift::type_class::list<::apache::thrift::type_class::integral>>, std::unordered_map<::std::string, ::std::vector< ::nebula::cpp2::PartitionID>>>::serializedSize(*prot_, this->leader_parts); + xfer += prot_->serializedFieldSize("all_parts", apache::thrift::protocol::T_MAP, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::binary, ::apache::thrift::type_class::list<::apache::thrift::type_class::integral>>, std::unordered_map<::std::string, ::std::vector< ::nebula::cpp2::PartitionID>>>::serializedSize(*prot_, this->all_parts); + xfer += prot_->serializedFieldSize("role", apache::thrift::protocol::T_I32, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::HostRole>::serializedSize(*prot_, this->role); + xfer += prot_->serializedFieldSize("git_info_sha", apache::thrift::protocol::T_STRING, 6); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->git_info_sha); + if (this->zone_name_ref().has_value()) { + xfer += prot_->serializedFieldSize("zone_name", apache::thrift::protocol::T_STRING, 7); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->zone_name); + } + if (this->version_ref().has_value()) { + xfer += prot_->serializedFieldSize("version", apache::thrift::protocol::T_STRING, 8); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->version); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t HostItem::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("HostItem"); + xfer += prot_->serializedFieldSize("hostAddr", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->hostAddr); + xfer += prot_->serializedFieldSize("status", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::HostStatus>::serializedSize(*prot_, this->status); + xfer += prot_->serializedFieldSize("leader_parts", apache::thrift::protocol::T_MAP, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::binary, ::apache::thrift::type_class::list<::apache::thrift::type_class::integral>>, std::unordered_map<::std::string, ::std::vector< ::nebula::cpp2::PartitionID>>>::serializedSize(*prot_, this->leader_parts); + xfer += prot_->serializedFieldSize("all_parts", apache::thrift::protocol::T_MAP, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::binary, ::apache::thrift::type_class::list<::apache::thrift::type_class::integral>>, std::unordered_map<::std::string, ::std::vector< ::nebula::cpp2::PartitionID>>>::serializedSize(*prot_, this->all_parts); + xfer += prot_->serializedFieldSize("role", apache::thrift::protocol::T_I32, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::HostRole>::serializedSize(*prot_, this->role); + xfer += prot_->serializedFieldSize("git_info_sha", apache::thrift::protocol::T_STRING, 6); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->git_info_sha); + if (this->zone_name_ref().has_value()) { + xfer += prot_->serializedFieldSize("zone_name", apache::thrift::protocol::T_STRING, 7); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->zone_name); + } + if (this->version_ref().has_value()) { + xfer += prot_->serializedFieldSize("version", apache::thrift::protocol::T_STRING, 8); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->version); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t HostItem::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("HostItem"); + xfer += prot_->writeFieldBegin("hostAddr", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::write(*prot_, this->hostAddr); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("status", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::HostStatus>::write(*prot_, this->status); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("leader_parts", apache::thrift::protocol::T_MAP, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::binary, ::apache::thrift::type_class::list<::apache::thrift::type_class::integral>>, std::unordered_map<::std::string, ::std::vector< ::nebula::cpp2::PartitionID>>>::write(*prot_, this->leader_parts); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("all_parts", apache::thrift::protocol::T_MAP, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::binary, ::apache::thrift::type_class::list<::apache::thrift::type_class::integral>>, std::unordered_map<::std::string, ::std::vector< ::nebula::cpp2::PartitionID>>>::write(*prot_, this->all_parts); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("role", apache::thrift::protocol::T_I32, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::HostRole>::write(*prot_, this->role); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("git_info_sha", apache::thrift::protocol::T_STRING, 6); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->git_info_sha); + xfer += prot_->writeFieldEnd(); + if (this->zone_name_ref().has_value()) { + xfer += prot_->writeFieldBegin("zone_name", apache::thrift::protocol::T_STRING, 7); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->zone_name); + xfer += prot_->writeFieldEnd(); + } + if (this->version_ref().has_value()) { + xfer += prot_->writeFieldBegin("version", apache::thrift::protocol::T_STRING, 8); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->version); + xfer += prot_->writeFieldEnd(); + } + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void HostItem::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t HostItem::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t HostItem::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t HostItem::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void HostItem::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t HostItem::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t HostItem::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t HostItem::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void UserItem::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_account: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->account, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.account = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_BOOL))) { + goto _loop; + } +_readField_is_lock: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::readWithContext(*iprot, this->is_lock, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.is_lock = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_max_queries_per_hour: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::readWithContext(*iprot, this->max_queries_per_hour, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.max_queries_per_hour = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 4, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_max_updates_per_hour: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::readWithContext(*iprot, this->max_updates_per_hour, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.max_updates_per_hour = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 4, + 5, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_max_connections_per_hour: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::readWithContext(*iprot, this->max_connections_per_hour, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.max_connections_per_hour = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 5, + 6, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_max_user_connections: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::readWithContext(*iprot, this->max_user_connections, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.max_user_connections = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 6, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_account; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_BOOL))) { + goto _readField_is_lock; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_max_queries_per_hour; + } else { + goto _skip; + } + } + case 4: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_max_updates_per_hour; + } else { + goto _skip; + } + } + case 5: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_max_connections_per_hour; + } else { + goto _skip; + } + } + case 6: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_max_user_connections; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t UserItem::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("UserItem"); + xfer += prot_->serializedFieldSize("account", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->account); + xfer += prot_->serializedFieldSize("is_lock", apache::thrift::protocol::T_BOOL, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::serializedSize(*prot_, this->is_lock); + xfer += prot_->serializedFieldSize("max_queries_per_hour", apache::thrift::protocol::T_I32, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::serializedSize(*prot_, this->max_queries_per_hour); + xfer += prot_->serializedFieldSize("max_updates_per_hour", apache::thrift::protocol::T_I32, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::serializedSize(*prot_, this->max_updates_per_hour); + xfer += prot_->serializedFieldSize("max_connections_per_hour", apache::thrift::protocol::T_I32, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::serializedSize(*prot_, this->max_connections_per_hour); + xfer += prot_->serializedFieldSize("max_user_connections", apache::thrift::protocol::T_I32, 6); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::serializedSize(*prot_, this->max_user_connections); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t UserItem::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("UserItem"); + xfer += prot_->serializedFieldSize("account", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->account); + xfer += prot_->serializedFieldSize("is_lock", apache::thrift::protocol::T_BOOL, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::serializedSize(*prot_, this->is_lock); + xfer += prot_->serializedFieldSize("max_queries_per_hour", apache::thrift::protocol::T_I32, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::serializedSize(*prot_, this->max_queries_per_hour); + xfer += prot_->serializedFieldSize("max_updates_per_hour", apache::thrift::protocol::T_I32, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::serializedSize(*prot_, this->max_updates_per_hour); + xfer += prot_->serializedFieldSize("max_connections_per_hour", apache::thrift::protocol::T_I32, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::serializedSize(*prot_, this->max_connections_per_hour); + xfer += prot_->serializedFieldSize("max_user_connections", apache::thrift::protocol::T_I32, 6); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::serializedSize(*prot_, this->max_user_connections); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t UserItem::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("UserItem"); + xfer += prot_->writeFieldBegin("account", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->account); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("is_lock", apache::thrift::protocol::T_BOOL, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::write(*prot_, this->is_lock); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("max_queries_per_hour", apache::thrift::protocol::T_I32, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::write(*prot_, this->max_queries_per_hour); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("max_updates_per_hour", apache::thrift::protocol::T_I32, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::write(*prot_, this->max_updates_per_hour); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("max_connections_per_hour", apache::thrift::protocol::T_I32, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::write(*prot_, this->max_connections_per_hour); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("max_user_connections", apache::thrift::protocol::T_I32, 6); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::write(*prot_, this->max_user_connections); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void UserItem::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t UserItem::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t UserItem::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t UserItem::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void UserItem::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t UserItem::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t UserItem::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t UserItem::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void RoleItem::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_user_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->user_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.user_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_space_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::readWithContext(*iprot, this->space_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.space_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_role_type: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::RoleType>::readWithContext(*iprot, this->role_type, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.role_type = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_user_id; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_space_id; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_role_type; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t RoleItem::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("RoleItem"); + xfer += prot_->serializedFieldSize("user_id", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->user_id); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("role_type", apache::thrift::protocol::T_I32, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::RoleType>::serializedSize(*prot_, this->role_type); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t RoleItem::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("RoleItem"); + xfer += prot_->serializedFieldSize("user_id", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->user_id); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("role_type", apache::thrift::protocol::T_I32, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::RoleType>::serializedSize(*prot_, this->role_type); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t RoleItem::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("RoleItem"); + xfer += prot_->writeFieldBegin("user_id", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->user_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("space_id", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::write(*prot_, this->space_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("role_type", apache::thrift::protocol::T_I32, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::RoleType>::write(*prot_, this->role_type); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void RoleItem::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t RoleItem::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t RoleItem::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t RoleItem::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void RoleItem::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t RoleItem::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t RoleItem::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t RoleItem::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void ExecResp::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_code: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::readWithContext(*iprot, this->code, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.code = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_id: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::variant, ::nebula::meta::cpp2::ID>::readWithContext(*iprot, this->id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_leader: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::readWithContext(*iprot, this->leader, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.leader = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_code; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_id; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_leader; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t ExecResp::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ExecResp"); + xfer += prot_->serializedFieldSize("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::serializedSize(*prot_, this->code); + xfer += prot_->serializedFieldSize("id", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::variant, ::nebula::meta::cpp2::ID>::serializedSize(*prot_, this->id); + xfer += prot_->serializedFieldSize("leader", apache::thrift::protocol::T_STRUCT, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->leader); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ExecResp::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ExecResp"); + xfer += prot_->serializedFieldSize("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::serializedSize(*prot_, this->code); + xfer += prot_->serializedFieldSize("id", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::variant, ::nebula::meta::cpp2::ID>::serializedSize(*prot_, this->id); + xfer += prot_->serializedFieldSize("leader", apache::thrift::protocol::T_STRUCT, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->leader); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ExecResp::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("ExecResp"); + xfer += prot_->writeFieldBegin("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::write(*prot_, this->code); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("id", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::variant, ::nebula::meta::cpp2::ID>::write(*prot_, this->id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("leader", apache::thrift::protocol::T_STRUCT, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::write(*prot_, this->leader); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void ExecResp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t ExecResp::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t ExecResp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t ExecResp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void ExecResp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t ExecResp::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t ExecResp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t ExecResp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void AdminJobReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_op: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::AdminJobOp>::readWithContext(*iprot, this->op, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.op = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_cmd: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::AdminCmd>::readWithContext(*iprot, this->cmd, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.cmd = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_paras: + { + _readState.beforeSubobject(iprot); + this->paras = ::std::vector<::std::string>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>, ::std::vector<::std::string>>::readWithContext(*iprot, this->paras, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.paras = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_op; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_cmd; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_paras; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t AdminJobReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("AdminJobReq"); + xfer += prot_->serializedFieldSize("op", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::AdminJobOp>::serializedSize(*prot_, this->op); + xfer += prot_->serializedFieldSize("cmd", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::AdminCmd>::serializedSize(*prot_, this->cmd); + xfer += prot_->serializedFieldSize("paras", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>, ::std::vector<::std::string>>::serializedSize(*prot_, this->paras); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t AdminJobReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("AdminJobReq"); + xfer += prot_->serializedFieldSize("op", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::AdminJobOp>::serializedSize(*prot_, this->op); + xfer += prot_->serializedFieldSize("cmd", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::AdminCmd>::serializedSize(*prot_, this->cmd); + xfer += prot_->serializedFieldSize("paras", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>, ::std::vector<::std::string>>::serializedSize(*prot_, this->paras); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t AdminJobReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("AdminJobReq"); + xfer += prot_->writeFieldBegin("op", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::AdminJobOp>::write(*prot_, this->op); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("cmd", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::AdminCmd>::write(*prot_, this->cmd); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("paras", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>, ::std::vector<::std::string>>::write(*prot_, this->paras); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void AdminJobReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t AdminJobReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t AdminJobReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t AdminJobReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void AdminJobReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t AdminJobReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t AdminJobReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t AdminJobReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void JobDesc::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::readWithContext(*iprot, this->id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_cmd: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::AdminCmd>::readWithContext(*iprot, this->cmd, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.cmd = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_paras: + { + _readState.beforeSubobject(iprot); + this->paras = ::std::vector<::std::string>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::string>, ::std::vector<::std::string>>::readWithContext(*iprot, this->paras, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.paras = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 4, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_status: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::JobStatus>::readWithContext(*iprot, this->status, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.status = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 4, + 5, + apache::thrift::protocol::T_I64))) { + goto _loop; + } +_readField_start_time: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::readWithContext(*iprot, this->start_time, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.start_time = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 5, + 6, + apache::thrift::protocol::T_I64))) { + goto _loop; + } +_readField_stop_time: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::readWithContext(*iprot, this->stop_time, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.stop_time = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 6, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_id; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_cmd; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_paras; + } else { + goto _skip; + } + } + case 4: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_status; + } else { + goto _skip; + } + } + case 5: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I64))) { + goto _readField_start_time; + } else { + goto _skip; + } + } + case 6: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I64))) { + goto _readField_stop_time; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t JobDesc::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("JobDesc"); + xfer += prot_->serializedFieldSize("id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::serializedSize(*prot_, this->id); + xfer += prot_->serializedFieldSize("cmd", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::AdminCmd>::serializedSize(*prot_, this->cmd); + xfer += prot_->serializedFieldSize("paras", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::string>, ::std::vector<::std::string>>::serializedSize(*prot_, this->paras); + xfer += prot_->serializedFieldSize("status", apache::thrift::protocol::T_I32, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::JobStatus>::serializedSize(*prot_, this->status); + xfer += prot_->serializedFieldSize("start_time", apache::thrift::protocol::T_I64, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::serializedSize(*prot_, this->start_time); + xfer += prot_->serializedFieldSize("stop_time", apache::thrift::protocol::T_I64, 6); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::serializedSize(*prot_, this->stop_time); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t JobDesc::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("JobDesc"); + xfer += prot_->serializedFieldSize("id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::serializedSize(*prot_, this->id); + xfer += prot_->serializedFieldSize("cmd", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::AdminCmd>::serializedSize(*prot_, this->cmd); + xfer += prot_->serializedFieldSize("paras", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::string>, ::std::vector<::std::string>>::serializedSize(*prot_, this->paras); + xfer += prot_->serializedFieldSize("status", apache::thrift::protocol::T_I32, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::JobStatus>::serializedSize(*prot_, this->status); + xfer += prot_->serializedFieldSize("start_time", apache::thrift::protocol::T_I64, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::serializedSize(*prot_, this->start_time); + xfer += prot_->serializedFieldSize("stop_time", apache::thrift::protocol::T_I64, 6); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::serializedSize(*prot_, this->stop_time); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t JobDesc::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("JobDesc"); + xfer += prot_->writeFieldBegin("id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::write(*prot_, this->id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("cmd", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::AdminCmd>::write(*prot_, this->cmd); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("paras", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::string>, ::std::vector<::std::string>>::write(*prot_, this->paras); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("status", apache::thrift::protocol::T_I32, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::JobStatus>::write(*prot_, this->status); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("start_time", apache::thrift::protocol::T_I64, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::write(*prot_, this->start_time); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("stop_time", apache::thrift::protocol::T_I64, 6); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::write(*prot_, this->stop_time); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void JobDesc::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t JobDesc::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t JobDesc::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t JobDesc::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void JobDesc::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t JobDesc::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t JobDesc::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t JobDesc::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void TaskDesc::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_task_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::readWithContext(*iprot, this->task_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.task_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_host: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::readWithContext(*iprot, this->host, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.host = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_status: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::JobStatus>::readWithContext(*iprot, this->status, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.status = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 4, + apache::thrift::protocol::T_I64))) { + goto _loop; + } +_readField_start_time: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::readWithContext(*iprot, this->start_time, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.start_time = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 4, + 5, + apache::thrift::protocol::T_I64))) { + goto _loop; + } +_readField_stop_time: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::readWithContext(*iprot, this->stop_time, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.stop_time = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 5, + 6, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_job_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::readWithContext(*iprot, this->job_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.job_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 6, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_task_id; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_host; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_status; + } else { + goto _skip; + } + } + case 4: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I64))) { + goto _readField_start_time; + } else { + goto _skip; + } + } + case 5: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I64))) { + goto _readField_stop_time; + } else { + goto _skip; + } + } + case 6: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_job_id; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t TaskDesc::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("TaskDesc"); + xfer += prot_->serializedFieldSize("task_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::serializedSize(*prot_, this->task_id); + xfer += prot_->serializedFieldSize("host", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->host); + xfer += prot_->serializedFieldSize("status", apache::thrift::protocol::T_I32, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::JobStatus>::serializedSize(*prot_, this->status); + xfer += prot_->serializedFieldSize("start_time", apache::thrift::protocol::T_I64, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::serializedSize(*prot_, this->start_time); + xfer += prot_->serializedFieldSize("stop_time", apache::thrift::protocol::T_I64, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::serializedSize(*prot_, this->stop_time); + xfer += prot_->serializedFieldSize("job_id", apache::thrift::protocol::T_I32, 6); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::serializedSize(*prot_, this->job_id); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t TaskDesc::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("TaskDesc"); + xfer += prot_->serializedFieldSize("task_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::serializedSize(*prot_, this->task_id); + xfer += prot_->serializedFieldSize("host", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->host); + xfer += prot_->serializedFieldSize("status", apache::thrift::protocol::T_I32, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::JobStatus>::serializedSize(*prot_, this->status); + xfer += prot_->serializedFieldSize("start_time", apache::thrift::protocol::T_I64, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::serializedSize(*prot_, this->start_time); + xfer += prot_->serializedFieldSize("stop_time", apache::thrift::protocol::T_I64, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::serializedSize(*prot_, this->stop_time); + xfer += prot_->serializedFieldSize("job_id", apache::thrift::protocol::T_I32, 6); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::serializedSize(*prot_, this->job_id); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t TaskDesc::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("TaskDesc"); + xfer += prot_->writeFieldBegin("task_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::write(*prot_, this->task_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("host", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::write(*prot_, this->host); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("status", apache::thrift::protocol::T_I32, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::JobStatus>::write(*prot_, this->status); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("start_time", apache::thrift::protocol::T_I64, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::write(*prot_, this->start_time); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("stop_time", apache::thrift::protocol::T_I64, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::write(*prot_, this->stop_time); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("job_id", apache::thrift::protocol::T_I32, 6); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::write(*prot_, this->job_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void TaskDesc::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t TaskDesc::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t TaskDesc::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t TaskDesc::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void TaskDesc::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t TaskDesc::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t TaskDesc::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t TaskDesc::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void AdminJobResult::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_job_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::readWithContext(*iprot, this->job_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.job_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_job_desc: + { + _readState.beforeSubobject(iprot); + this->job_desc = ::std::vector< ::nebula::meta::cpp2::JobDesc>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::JobDesc>>::readWithContext(*iprot, this->job_desc, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.job_desc = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_task_desc: + { + _readState.beforeSubobject(iprot); + this->task_desc = ::std::vector< ::nebula::meta::cpp2::TaskDesc>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::TaskDesc>>::readWithContext(*iprot, this->task_desc, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.task_desc = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 4, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_recovered_job_num: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::readWithContext(*iprot, this->recovered_job_num, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.recovered_job_num = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 4, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_job_id; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_job_desc; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_task_desc; + } else { + goto _skip; + } + } + case 4: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_recovered_job_num; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t AdminJobResult::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("AdminJobResult"); + if (this->job_id_ref().has_value()) { + xfer += prot_->serializedFieldSize("job_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::serializedSize(*prot_, this->job_id); + } + if (this->job_desc_ref().has_value()) { + xfer += prot_->serializedFieldSize("job_desc", apache::thrift::protocol::T_LIST, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::JobDesc>>::serializedSize(*prot_, this->job_desc); + } + if (this->task_desc_ref().has_value()) { + xfer += prot_->serializedFieldSize("task_desc", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::TaskDesc>>::serializedSize(*prot_, this->task_desc); + } + if (this->recovered_job_num_ref().has_value()) { + xfer += prot_->serializedFieldSize("recovered_job_num", apache::thrift::protocol::T_I32, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::serializedSize(*prot_, this->recovered_job_num); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t AdminJobResult::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("AdminJobResult"); + if (this->job_id_ref().has_value()) { + xfer += prot_->serializedFieldSize("job_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::serializedSize(*prot_, this->job_id); + } + if (this->job_desc_ref().has_value()) { + xfer += prot_->serializedFieldSize("job_desc", apache::thrift::protocol::T_LIST, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::JobDesc>>::serializedSize(*prot_, this->job_desc); + } + if (this->task_desc_ref().has_value()) { + xfer += prot_->serializedFieldSize("task_desc", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::TaskDesc>>::serializedSize(*prot_, this->task_desc); + } + if (this->recovered_job_num_ref().has_value()) { + xfer += prot_->serializedFieldSize("recovered_job_num", apache::thrift::protocol::T_I32, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::serializedSize(*prot_, this->recovered_job_num); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t AdminJobResult::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("AdminJobResult"); + if (this->job_id_ref().has_value()) { + xfer += prot_->writeFieldBegin("job_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::write(*prot_, this->job_id); + xfer += prot_->writeFieldEnd(); + } + if (this->job_desc_ref().has_value()) { + xfer += prot_->writeFieldBegin("job_desc", apache::thrift::protocol::T_LIST, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::JobDesc>>::write(*prot_, this->job_desc); + xfer += prot_->writeFieldEnd(); + } + if (this->task_desc_ref().has_value()) { + xfer += prot_->writeFieldBegin("task_desc", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::TaskDesc>>::write(*prot_, this->task_desc); + xfer += prot_->writeFieldEnd(); + } + if (this->recovered_job_num_ref().has_value()) { + xfer += prot_->writeFieldBegin("recovered_job_num", apache::thrift::protocol::T_I32, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::write(*prot_, this->recovered_job_num); + xfer += prot_->writeFieldEnd(); + } + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void AdminJobResult::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t AdminJobResult::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t AdminJobResult::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t AdminJobResult::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void AdminJobResult::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t AdminJobResult::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t AdminJobResult::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t AdminJobResult::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void AdminJobResp::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_code: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::readWithContext(*iprot, this->code, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.code = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_leader: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::readWithContext(*iprot, this->leader, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.leader = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_result: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::AdminJobResult>::readWithContext(*iprot, this->result, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.result = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_code; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_leader; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_result; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t AdminJobResp::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("AdminJobResp"); + xfer += prot_->serializedFieldSize("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::serializedSize(*prot_, this->code); + xfer += prot_->serializedFieldSize("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->leader); + xfer += prot_->serializedFieldSize("result", apache::thrift::protocol::T_STRUCT, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::AdminJobResult>::serializedSize(*prot_, this->result); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t AdminJobResp::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("AdminJobResp"); + xfer += prot_->serializedFieldSize("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::serializedSize(*prot_, this->code); + xfer += prot_->serializedFieldSize("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->leader); + xfer += prot_->serializedFieldSize("result", apache::thrift::protocol::T_STRUCT, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::AdminJobResult>::serializedSize(*prot_, this->result); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t AdminJobResp::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("AdminJobResp"); + xfer += prot_->writeFieldBegin("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::write(*prot_, this->code); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::write(*prot_, this->leader); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("result", apache::thrift::protocol::T_STRUCT, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::AdminJobResult>::write(*prot_, this->result); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void AdminJobResp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t AdminJobResp::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t AdminJobResp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t AdminJobResp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void AdminJobResp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t AdminJobResp::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t AdminJobResp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t AdminJobResp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void Correlativity::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_part_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::PartitionID>::readWithContext(*iprot, this->part_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.part_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_DOUBLE))) { + goto _loop; + } +_readField_proportion: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::floating_point, double>::readWithContext(*iprot, this->proportion, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.proportion = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_part_id; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_DOUBLE))) { + goto _readField_proportion; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t Correlativity::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("Correlativity"); + xfer += prot_->serializedFieldSize("part_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::PartitionID>::serializedSize(*prot_, this->part_id); + xfer += prot_->serializedFieldSize("proportion", apache::thrift::protocol::T_DOUBLE, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::floating_point, double>::serializedSize(*prot_, this->proportion); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t Correlativity::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("Correlativity"); + xfer += prot_->serializedFieldSize("part_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::PartitionID>::serializedSize(*prot_, this->part_id); + xfer += prot_->serializedFieldSize("proportion", apache::thrift::protocol::T_DOUBLE, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::floating_point, double>::serializedSize(*prot_, this->proportion); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t Correlativity::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("Correlativity"); + xfer += prot_->writeFieldBegin("part_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::PartitionID>::write(*prot_, this->part_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("proportion", apache::thrift::protocol::T_DOUBLE, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::floating_point, double>::write(*prot_, this->proportion); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void Correlativity::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t Correlativity::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t Correlativity::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t Correlativity::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void Correlativity::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t Correlativity::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t Correlativity::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t Correlativity::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void StatsItem::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_MAP))) { + goto _loop; + } +_readField_tag_vertices: + { + _readState.beforeSubobject(iprot); + this->tag_vertices = std::unordered_map<::std::string, int64_t>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::binary, ::apache::thrift::type_class::integral>, std::unordered_map<::std::string, int64_t>>::readWithContext(*iprot, this->tag_vertices, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.tag_vertices = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_MAP))) { + goto _loop; + } +_readField_edges: + { + _readState.beforeSubobject(iprot); + this->edges = std::unordered_map<::std::string, int64_t>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::binary, ::apache::thrift::type_class::integral>, std::unordered_map<::std::string, int64_t>>::readWithContext(*iprot, this->edges, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.edges = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_I64))) { + goto _loop; + } +_readField_space_vertices: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::readWithContext(*iprot, this->space_vertices, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.space_vertices = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 4, + apache::thrift::protocol::T_I64))) { + goto _loop; + } +_readField_space_edges: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::readWithContext(*iprot, this->space_edges, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.space_edges = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 4, + 5, + apache::thrift::protocol::T_MAP))) { + goto _loop; + } +_readField_positive_part_correlativity: + { + _readState.beforeSubobject(iprot); + this->positive_part_correlativity = std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::meta::cpp2::Correlativity>>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>>, std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::meta::cpp2::Correlativity>>>::readWithContext(*iprot, this->positive_part_correlativity, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.positive_part_correlativity = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 5, + 6, + apache::thrift::protocol::T_MAP))) { + goto _loop; + } +_readField_negative_part_correlativity: + { + _readState.beforeSubobject(iprot); + this->negative_part_correlativity = std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::meta::cpp2::Correlativity>>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>>, std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::meta::cpp2::Correlativity>>>::readWithContext(*iprot, this->negative_part_correlativity, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.negative_part_correlativity = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 6, + 7, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_status: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::JobStatus>::readWithContext(*iprot, this->status, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.status = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 7, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_MAP))) { + goto _readField_tag_vertices; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_MAP))) { + goto _readField_edges; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I64))) { + goto _readField_space_vertices; + } else { + goto _skip; + } + } + case 4: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I64))) { + goto _readField_space_edges; + } else { + goto _skip; + } + } + case 5: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_MAP))) { + goto _readField_positive_part_correlativity; + } else { + goto _skip; + } + } + case 6: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_MAP))) { + goto _readField_negative_part_correlativity; + } else { + goto _skip; + } + } + case 7: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_status; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t StatsItem::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("StatsItem"); + xfer += prot_->serializedFieldSize("tag_vertices", apache::thrift::protocol::T_MAP, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::binary, ::apache::thrift::type_class::integral>, std::unordered_map<::std::string, int64_t>>::serializedSize(*prot_, this->tag_vertices); + xfer += prot_->serializedFieldSize("edges", apache::thrift::protocol::T_MAP, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::binary, ::apache::thrift::type_class::integral>, std::unordered_map<::std::string, int64_t>>::serializedSize(*prot_, this->edges); + xfer += prot_->serializedFieldSize("space_vertices", apache::thrift::protocol::T_I64, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::serializedSize(*prot_, this->space_vertices); + xfer += prot_->serializedFieldSize("space_edges", apache::thrift::protocol::T_I64, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::serializedSize(*prot_, this->space_edges); + xfer += prot_->serializedFieldSize("positive_part_correlativity", apache::thrift::protocol::T_MAP, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>>, std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::meta::cpp2::Correlativity>>>::serializedSize(*prot_, this->positive_part_correlativity); + xfer += prot_->serializedFieldSize("negative_part_correlativity", apache::thrift::protocol::T_MAP, 6); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>>, std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::meta::cpp2::Correlativity>>>::serializedSize(*prot_, this->negative_part_correlativity); + xfer += prot_->serializedFieldSize("status", apache::thrift::protocol::T_I32, 7); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::JobStatus>::serializedSize(*prot_, this->status); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t StatsItem::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("StatsItem"); + xfer += prot_->serializedFieldSize("tag_vertices", apache::thrift::protocol::T_MAP, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::binary, ::apache::thrift::type_class::integral>, std::unordered_map<::std::string, int64_t>>::serializedSize(*prot_, this->tag_vertices); + xfer += prot_->serializedFieldSize("edges", apache::thrift::protocol::T_MAP, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::binary, ::apache::thrift::type_class::integral>, std::unordered_map<::std::string, int64_t>>::serializedSize(*prot_, this->edges); + xfer += prot_->serializedFieldSize("space_vertices", apache::thrift::protocol::T_I64, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::serializedSize(*prot_, this->space_vertices); + xfer += prot_->serializedFieldSize("space_edges", apache::thrift::protocol::T_I64, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::serializedSize(*prot_, this->space_edges); + xfer += prot_->serializedFieldSize("positive_part_correlativity", apache::thrift::protocol::T_MAP, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>>, std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::meta::cpp2::Correlativity>>>::serializedSize(*prot_, this->positive_part_correlativity); + xfer += prot_->serializedFieldSize("negative_part_correlativity", apache::thrift::protocol::T_MAP, 6); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>>, std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::meta::cpp2::Correlativity>>>::serializedSize(*prot_, this->negative_part_correlativity); + xfer += prot_->serializedFieldSize("status", apache::thrift::protocol::T_I32, 7); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::JobStatus>::serializedSize(*prot_, this->status); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t StatsItem::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("StatsItem"); + xfer += prot_->writeFieldBegin("tag_vertices", apache::thrift::protocol::T_MAP, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::binary, ::apache::thrift::type_class::integral>, std::unordered_map<::std::string, int64_t>>::write(*prot_, this->tag_vertices); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("edges", apache::thrift::protocol::T_MAP, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::binary, ::apache::thrift::type_class::integral>, std::unordered_map<::std::string, int64_t>>::write(*prot_, this->edges); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("space_vertices", apache::thrift::protocol::T_I64, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::write(*prot_, this->space_vertices); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("space_edges", apache::thrift::protocol::T_I64, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::write(*prot_, this->space_edges); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("positive_part_correlativity", apache::thrift::protocol::T_MAP, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>>, std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::meta::cpp2::Correlativity>>>::write(*prot_, this->positive_part_correlativity); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("negative_part_correlativity", apache::thrift::protocol::T_MAP, 6); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>>, std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::meta::cpp2::Correlativity>>>::write(*prot_, this->negative_part_correlativity); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("status", apache::thrift::protocol::T_I32, 7); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::JobStatus>::write(*prot_, this->status); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void StatsItem::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t StatsItem::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t StatsItem::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t StatsItem::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void StatsItem::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t StatsItem::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t StatsItem::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t StatsItem::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void CreateSpaceReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_properties: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::SpaceDesc>::readWithContext(*iprot, this->properties, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.properties = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_BOOL))) { + goto _loop; + } +_readField_if_not_exists: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::readWithContext(*iprot, this->if_not_exists, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.if_not_exists = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_properties; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_BOOL))) { + goto _readField_if_not_exists; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t CreateSpaceReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("CreateSpaceReq"); + xfer += prot_->serializedFieldSize("properties", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::SpaceDesc>::serializedSize(*prot_, this->properties); + xfer += prot_->serializedFieldSize("if_not_exists", apache::thrift::protocol::T_BOOL, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::serializedSize(*prot_, this->if_not_exists); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t CreateSpaceReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("CreateSpaceReq"); + xfer += prot_->serializedFieldSize("properties", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::SpaceDesc>::serializedSize(*prot_, this->properties); + xfer += prot_->serializedFieldSize("if_not_exists", apache::thrift::protocol::T_BOOL, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::serializedSize(*prot_, this->if_not_exists); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t CreateSpaceReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("CreateSpaceReq"); + xfer += prot_->writeFieldBegin("properties", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::SpaceDesc>::write(*prot_, this->properties); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("if_not_exists", apache::thrift::protocol::T_BOOL, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::write(*prot_, this->if_not_exists); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void CreateSpaceReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t CreateSpaceReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t CreateSpaceReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t CreateSpaceReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void CreateSpaceReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t CreateSpaceReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t CreateSpaceReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t CreateSpaceReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void CreateSpaceAsReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_old_space_name: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->old_space_name, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.old_space_name = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_new_space_name: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->new_space_name, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.new_space_name = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_old_space_name; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_new_space_name; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t CreateSpaceAsReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("CreateSpaceAsReq"); + xfer += prot_->serializedFieldSize("old_space_name", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->old_space_name); + xfer += prot_->serializedFieldSize("new_space_name", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->new_space_name); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t CreateSpaceAsReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("CreateSpaceAsReq"); + xfer += prot_->serializedFieldSize("old_space_name", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->old_space_name); + xfer += prot_->serializedFieldSize("new_space_name", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->new_space_name); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t CreateSpaceAsReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("CreateSpaceAsReq"); + xfer += prot_->writeFieldBegin("old_space_name", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->old_space_name); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("new_space_name", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->new_space_name); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void CreateSpaceAsReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t CreateSpaceAsReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t CreateSpaceAsReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t CreateSpaceAsReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void CreateSpaceAsReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t CreateSpaceAsReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t CreateSpaceAsReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t CreateSpaceAsReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void DropSpaceReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_space_name: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->space_name, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.space_name = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_BOOL))) { + goto _loop; + } +_readField_if_exists: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::readWithContext(*iprot, this->if_exists, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.if_exists = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_space_name; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_BOOL))) { + goto _readField_if_exists; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t DropSpaceReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("DropSpaceReq"); + xfer += prot_->serializedFieldSize("space_name", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->space_name); + xfer += prot_->serializedFieldSize("if_exists", apache::thrift::protocol::T_BOOL, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::serializedSize(*prot_, this->if_exists); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t DropSpaceReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("DropSpaceReq"); + xfer += prot_->serializedFieldSize("space_name", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->space_name); + xfer += prot_->serializedFieldSize("if_exists", apache::thrift::protocol::T_BOOL, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::serializedSize(*prot_, this->if_exists); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t DropSpaceReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("DropSpaceReq"); + xfer += prot_->writeFieldBegin("space_name", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->space_name); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("if_exists", apache::thrift::protocol::T_BOOL, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::write(*prot_, this->if_exists); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void DropSpaceReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t DropSpaceReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t DropSpaceReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t DropSpaceReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void DropSpaceReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t DropSpaceReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t DropSpaceReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t DropSpaceReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void ListSpacesReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + default: + { + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t ListSpacesReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ListSpacesReq"); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ListSpacesReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ListSpacesReq"); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ListSpacesReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("ListSpacesReq"); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void ListSpacesReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t ListSpacesReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t ListSpacesReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t ListSpacesReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void ListSpacesReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t ListSpacesReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t ListSpacesReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t ListSpacesReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void ListSpacesResp::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_code: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::readWithContext(*iprot, this->code, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.code = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_leader: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::readWithContext(*iprot, this->leader, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.leader = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_spaces: + { + _readState.beforeSubobject(iprot); + this->spaces = ::std::vector< ::nebula::meta::cpp2::IdName>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::IdName>>::readWithContext(*iprot, this->spaces, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.spaces = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_code; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_leader; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_spaces; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t ListSpacesResp::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ListSpacesResp"); + xfer += prot_->serializedFieldSize("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::serializedSize(*prot_, this->code); + xfer += prot_->serializedFieldSize("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->leader); + xfer += prot_->serializedFieldSize("spaces", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::IdName>>::serializedSize(*prot_, this->spaces); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ListSpacesResp::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ListSpacesResp"); + xfer += prot_->serializedFieldSize("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::serializedSize(*prot_, this->code); + xfer += prot_->serializedFieldSize("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->leader); + xfer += prot_->serializedFieldSize("spaces", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::IdName>>::serializedSize(*prot_, this->spaces); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ListSpacesResp::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("ListSpacesResp"); + xfer += prot_->writeFieldBegin("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::write(*prot_, this->code); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::write(*prot_, this->leader); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("spaces", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::IdName>>::write(*prot_, this->spaces); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void ListSpacesResp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t ListSpacesResp::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t ListSpacesResp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t ListSpacesResp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void ListSpacesResp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t ListSpacesResp::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t ListSpacesResp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t ListSpacesResp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void GetSpaceReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_space_name: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->space_name, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.space_name = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_space_name; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t GetSpaceReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("GetSpaceReq"); + xfer += prot_->serializedFieldSize("space_name", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->space_name); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t GetSpaceReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("GetSpaceReq"); + xfer += prot_->serializedFieldSize("space_name", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->space_name); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t GetSpaceReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("GetSpaceReq"); + xfer += prot_->writeFieldBegin("space_name", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->space_name); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void GetSpaceReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t GetSpaceReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t GetSpaceReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t GetSpaceReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void GetSpaceReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t GetSpaceReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t GetSpaceReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t GetSpaceReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void GetSpaceResp::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_code: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::readWithContext(*iprot, this->code, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.code = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_leader: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::readWithContext(*iprot, this->leader, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.leader = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_item: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::SpaceItem>::readWithContext(*iprot, this->item, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.item = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_code; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_leader; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_item; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t GetSpaceResp::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("GetSpaceResp"); + xfer += prot_->serializedFieldSize("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::serializedSize(*prot_, this->code); + xfer += prot_->serializedFieldSize("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->leader); + xfer += prot_->serializedFieldSize("item", apache::thrift::protocol::T_STRUCT, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::SpaceItem>::serializedSize(*prot_, this->item); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t GetSpaceResp::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("GetSpaceResp"); + xfer += prot_->serializedFieldSize("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::serializedSize(*prot_, this->code); + xfer += prot_->serializedFieldSize("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->leader); + xfer += prot_->serializedFieldSize("item", apache::thrift::protocol::T_STRUCT, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::SpaceItem>::serializedSize(*prot_, this->item); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t GetSpaceResp::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("GetSpaceResp"); + xfer += prot_->writeFieldBegin("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::write(*prot_, this->code); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::write(*prot_, this->leader); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("item", apache::thrift::protocol::T_STRUCT, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::SpaceItem>::write(*prot_, this->item); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void GetSpaceResp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t GetSpaceResp::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t GetSpaceResp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t GetSpaceResp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void GetSpaceResp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t GetSpaceResp::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t GetSpaceResp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t GetSpaceResp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void CreateTagReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_space_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::readWithContext(*iprot, this->space_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.space_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_tag_name: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->tag_name, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.tag_name = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_schema: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::Schema>::readWithContext(*iprot, this->schema, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.schema = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 4, + apache::thrift::protocol::T_BOOL))) { + goto _loop; + } +_readField_if_not_exists: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::readWithContext(*iprot, this->if_not_exists, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.if_not_exists = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 4, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_space_id; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_tag_name; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_schema; + } else { + goto _skip; + } + } + case 4: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_BOOL))) { + goto _readField_if_not_exists; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t CreateTagReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("CreateTagReq"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("tag_name", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->tag_name); + xfer += prot_->serializedFieldSize("schema", apache::thrift::protocol::T_STRUCT, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::Schema>::serializedSize(*prot_, this->schema); + xfer += prot_->serializedFieldSize("if_not_exists", apache::thrift::protocol::T_BOOL, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::serializedSize(*prot_, this->if_not_exists); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t CreateTagReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("CreateTagReq"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("tag_name", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->tag_name); + xfer += prot_->serializedFieldSize("schema", apache::thrift::protocol::T_STRUCT, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::Schema>::serializedSize(*prot_, this->schema); + xfer += prot_->serializedFieldSize("if_not_exists", apache::thrift::protocol::T_BOOL, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::serializedSize(*prot_, this->if_not_exists); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t CreateTagReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("CreateTagReq"); + xfer += prot_->writeFieldBegin("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::write(*prot_, this->space_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("tag_name", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->tag_name); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("schema", apache::thrift::protocol::T_STRUCT, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::Schema>::write(*prot_, this->schema); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("if_not_exists", apache::thrift::protocol::T_BOOL, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::write(*prot_, this->if_not_exists); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void CreateTagReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t CreateTagReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t CreateTagReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t CreateTagReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void CreateTagReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t CreateTagReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t CreateTagReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t CreateTagReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void AlterTagReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_space_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::readWithContext(*iprot, this->space_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.space_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_tag_name: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->tag_name, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.tag_name = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_tag_items: + { + _readState.beforeSubobject(iprot); + this->tag_items = ::std::vector< ::nebula::meta::cpp2::AlterSchemaItem>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::AlterSchemaItem>>::readWithContext(*iprot, this->tag_items, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.tag_items = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 4, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_schema_prop: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::SchemaProp>::readWithContext(*iprot, this->schema_prop, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.schema_prop = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 4, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_space_id; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_tag_name; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_tag_items; + } else { + goto _skip; + } + } + case 4: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_schema_prop; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t AlterTagReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("AlterTagReq"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("tag_name", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->tag_name); + xfer += prot_->serializedFieldSize("tag_items", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::AlterSchemaItem>>::serializedSize(*prot_, this->tag_items); + xfer += prot_->serializedFieldSize("schema_prop", apache::thrift::protocol::T_STRUCT, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::SchemaProp>::serializedSize(*prot_, this->schema_prop); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t AlterTagReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("AlterTagReq"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("tag_name", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->tag_name); + xfer += prot_->serializedFieldSize("tag_items", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::AlterSchemaItem>>::serializedSize(*prot_, this->tag_items); + xfer += prot_->serializedFieldSize("schema_prop", apache::thrift::protocol::T_STRUCT, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::SchemaProp>::serializedSize(*prot_, this->schema_prop); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t AlterTagReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("AlterTagReq"); + xfer += prot_->writeFieldBegin("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::write(*prot_, this->space_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("tag_name", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->tag_name); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("tag_items", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::AlterSchemaItem>>::write(*prot_, this->tag_items); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("schema_prop", apache::thrift::protocol::T_STRUCT, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::SchemaProp>::write(*prot_, this->schema_prop); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void AlterTagReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t AlterTagReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t AlterTagReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t AlterTagReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void AlterTagReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t AlterTagReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t AlterTagReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t AlterTagReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void DropTagReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_space_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::readWithContext(*iprot, this->space_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.space_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_tag_name: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->tag_name, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.tag_name = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_BOOL))) { + goto _loop; + } +_readField_if_exists: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::readWithContext(*iprot, this->if_exists, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.if_exists = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_space_id; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_tag_name; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_BOOL))) { + goto _readField_if_exists; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t DropTagReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("DropTagReq"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("tag_name", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->tag_name); + xfer += prot_->serializedFieldSize("if_exists", apache::thrift::protocol::T_BOOL, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::serializedSize(*prot_, this->if_exists); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t DropTagReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("DropTagReq"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("tag_name", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->tag_name); + xfer += prot_->serializedFieldSize("if_exists", apache::thrift::protocol::T_BOOL, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::serializedSize(*prot_, this->if_exists); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t DropTagReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("DropTagReq"); + xfer += prot_->writeFieldBegin("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::write(*prot_, this->space_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("tag_name", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->tag_name); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("if_exists", apache::thrift::protocol::T_BOOL, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::write(*prot_, this->if_exists); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void DropTagReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t DropTagReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t DropTagReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t DropTagReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void DropTagReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t DropTagReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t DropTagReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t DropTagReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void ListTagsReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_space_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::readWithContext(*iprot, this->space_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.space_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_space_id; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t ListTagsReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ListTagsReq"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ListTagsReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ListTagsReq"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ListTagsReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("ListTagsReq"); + xfer += prot_->writeFieldBegin("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::write(*prot_, this->space_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void ListTagsReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t ListTagsReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t ListTagsReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t ListTagsReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void ListTagsReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t ListTagsReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t ListTagsReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t ListTagsReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void ListTagsResp::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_code: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::readWithContext(*iprot, this->code, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.code = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_leader: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::readWithContext(*iprot, this->leader, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.leader = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_tags: + { + _readState.beforeSubobject(iprot); + this->tags = ::std::vector< ::nebula::meta::cpp2::TagItem>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::TagItem>>::readWithContext(*iprot, this->tags, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.tags = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_code; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_leader; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_tags; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t ListTagsResp::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ListTagsResp"); + xfer += prot_->serializedFieldSize("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::serializedSize(*prot_, this->code); + xfer += prot_->serializedFieldSize("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->leader); + xfer += prot_->serializedFieldSize("tags", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::TagItem>>::serializedSize(*prot_, this->tags); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ListTagsResp::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ListTagsResp"); + xfer += prot_->serializedFieldSize("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::serializedSize(*prot_, this->code); + xfer += prot_->serializedFieldSize("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->leader); + xfer += prot_->serializedFieldSize("tags", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::TagItem>>::serializedSize(*prot_, this->tags); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ListTagsResp::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("ListTagsResp"); + xfer += prot_->writeFieldBegin("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::write(*prot_, this->code); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::write(*prot_, this->leader); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("tags", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::TagItem>>::write(*prot_, this->tags); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void ListTagsResp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t ListTagsResp::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t ListTagsResp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t ListTagsResp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void ListTagsResp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t ListTagsResp::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t ListTagsResp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t ListTagsResp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void GetTagReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_space_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::readWithContext(*iprot, this->space_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.space_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_tag_name: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->tag_name, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.tag_name = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_I64))) { + goto _loop; + } +_readField_version: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::meta::cpp2::SchemaVer>::readWithContext(*iprot, this->version, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.version = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_space_id; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_tag_name; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I64))) { + goto _readField_version; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t GetTagReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("GetTagReq"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("tag_name", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->tag_name); + xfer += prot_->serializedFieldSize("version", apache::thrift::protocol::T_I64, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::meta::cpp2::SchemaVer>::serializedSize(*prot_, this->version); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t GetTagReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("GetTagReq"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("tag_name", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->tag_name); + xfer += prot_->serializedFieldSize("version", apache::thrift::protocol::T_I64, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::meta::cpp2::SchemaVer>::serializedSize(*prot_, this->version); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t GetTagReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("GetTagReq"); + xfer += prot_->writeFieldBegin("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::write(*prot_, this->space_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("tag_name", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->tag_name); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("version", apache::thrift::protocol::T_I64, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::meta::cpp2::SchemaVer>::write(*prot_, this->version); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void GetTagReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t GetTagReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t GetTagReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t GetTagReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void GetTagReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t GetTagReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t GetTagReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t GetTagReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void GetTagResp::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_code: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::readWithContext(*iprot, this->code, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.code = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_leader: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::readWithContext(*iprot, this->leader, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.leader = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_schema: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::Schema>::readWithContext(*iprot, this->schema, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.schema = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_code; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_leader; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_schema; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t GetTagResp::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("GetTagResp"); + xfer += prot_->serializedFieldSize("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::serializedSize(*prot_, this->code); + xfer += prot_->serializedFieldSize("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->leader); + xfer += prot_->serializedFieldSize("schema", apache::thrift::protocol::T_STRUCT, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::Schema>::serializedSize(*prot_, this->schema); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t GetTagResp::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("GetTagResp"); + xfer += prot_->serializedFieldSize("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::serializedSize(*prot_, this->code); + xfer += prot_->serializedFieldSize("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->leader); + xfer += prot_->serializedFieldSize("schema", apache::thrift::protocol::T_STRUCT, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::Schema>::serializedSize(*prot_, this->schema); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t GetTagResp::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("GetTagResp"); + xfer += prot_->writeFieldBegin("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::write(*prot_, this->code); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::write(*prot_, this->leader); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("schema", apache::thrift::protocol::T_STRUCT, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::Schema>::write(*prot_, this->schema); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void GetTagResp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t GetTagResp::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t GetTagResp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t GetTagResp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void GetTagResp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t GetTagResp::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t GetTagResp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t GetTagResp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void CreateEdgeReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_space_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::readWithContext(*iprot, this->space_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.space_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_edge_name: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->edge_name, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.edge_name = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_schema: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::Schema>::readWithContext(*iprot, this->schema, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.schema = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 4, + apache::thrift::protocol::T_BOOL))) { + goto _loop; + } +_readField_if_not_exists: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::readWithContext(*iprot, this->if_not_exists, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.if_not_exists = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 4, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_space_id; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_edge_name; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_schema; + } else { + goto _skip; + } + } + case 4: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_BOOL))) { + goto _readField_if_not_exists; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t CreateEdgeReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("CreateEdgeReq"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("edge_name", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->edge_name); + xfer += prot_->serializedFieldSize("schema", apache::thrift::protocol::T_STRUCT, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::Schema>::serializedSize(*prot_, this->schema); + xfer += prot_->serializedFieldSize("if_not_exists", apache::thrift::protocol::T_BOOL, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::serializedSize(*prot_, this->if_not_exists); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t CreateEdgeReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("CreateEdgeReq"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("edge_name", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->edge_name); + xfer += prot_->serializedFieldSize("schema", apache::thrift::protocol::T_STRUCT, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::Schema>::serializedSize(*prot_, this->schema); + xfer += prot_->serializedFieldSize("if_not_exists", apache::thrift::protocol::T_BOOL, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::serializedSize(*prot_, this->if_not_exists); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t CreateEdgeReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("CreateEdgeReq"); + xfer += prot_->writeFieldBegin("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::write(*prot_, this->space_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("edge_name", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->edge_name); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("schema", apache::thrift::protocol::T_STRUCT, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::Schema>::write(*prot_, this->schema); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("if_not_exists", apache::thrift::protocol::T_BOOL, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::write(*prot_, this->if_not_exists); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void CreateEdgeReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t CreateEdgeReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t CreateEdgeReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t CreateEdgeReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void CreateEdgeReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t CreateEdgeReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t CreateEdgeReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t CreateEdgeReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void AlterEdgeReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_space_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::readWithContext(*iprot, this->space_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.space_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_edge_name: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->edge_name, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.edge_name = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_edge_items: + { + _readState.beforeSubobject(iprot); + this->edge_items = ::std::vector< ::nebula::meta::cpp2::AlterSchemaItem>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::AlterSchemaItem>>::readWithContext(*iprot, this->edge_items, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.edge_items = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 4, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_schema_prop: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::SchemaProp>::readWithContext(*iprot, this->schema_prop, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.schema_prop = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 4, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_space_id; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_edge_name; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_edge_items; + } else { + goto _skip; + } + } + case 4: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_schema_prop; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t AlterEdgeReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("AlterEdgeReq"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("edge_name", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->edge_name); + xfer += prot_->serializedFieldSize("edge_items", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::AlterSchemaItem>>::serializedSize(*prot_, this->edge_items); + xfer += prot_->serializedFieldSize("schema_prop", apache::thrift::protocol::T_STRUCT, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::SchemaProp>::serializedSize(*prot_, this->schema_prop); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t AlterEdgeReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("AlterEdgeReq"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("edge_name", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->edge_name); + xfer += prot_->serializedFieldSize("edge_items", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::AlterSchemaItem>>::serializedSize(*prot_, this->edge_items); + xfer += prot_->serializedFieldSize("schema_prop", apache::thrift::protocol::T_STRUCT, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::SchemaProp>::serializedSize(*prot_, this->schema_prop); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t AlterEdgeReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("AlterEdgeReq"); + xfer += prot_->writeFieldBegin("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::write(*prot_, this->space_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("edge_name", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->edge_name); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("edge_items", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::AlterSchemaItem>>::write(*prot_, this->edge_items); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("schema_prop", apache::thrift::protocol::T_STRUCT, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::SchemaProp>::write(*prot_, this->schema_prop); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void AlterEdgeReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t AlterEdgeReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t AlterEdgeReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t AlterEdgeReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void AlterEdgeReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t AlterEdgeReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t AlterEdgeReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t AlterEdgeReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void GetEdgeReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_space_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::readWithContext(*iprot, this->space_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.space_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_edge_name: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->edge_name, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.edge_name = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_I64))) { + goto _loop; + } +_readField_version: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::meta::cpp2::SchemaVer>::readWithContext(*iprot, this->version, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.version = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_space_id; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_edge_name; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I64))) { + goto _readField_version; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t GetEdgeReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("GetEdgeReq"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("edge_name", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->edge_name); + xfer += prot_->serializedFieldSize("version", apache::thrift::protocol::T_I64, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::meta::cpp2::SchemaVer>::serializedSize(*prot_, this->version); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t GetEdgeReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("GetEdgeReq"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("edge_name", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->edge_name); + xfer += prot_->serializedFieldSize("version", apache::thrift::protocol::T_I64, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::meta::cpp2::SchemaVer>::serializedSize(*prot_, this->version); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t GetEdgeReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("GetEdgeReq"); + xfer += prot_->writeFieldBegin("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::write(*prot_, this->space_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("edge_name", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->edge_name); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("version", apache::thrift::protocol::T_I64, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::meta::cpp2::SchemaVer>::write(*prot_, this->version); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void GetEdgeReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t GetEdgeReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t GetEdgeReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t GetEdgeReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void GetEdgeReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t GetEdgeReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t GetEdgeReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t GetEdgeReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void GetEdgeResp::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_code: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::readWithContext(*iprot, this->code, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.code = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_leader: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::readWithContext(*iprot, this->leader, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.leader = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_schema: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::Schema>::readWithContext(*iprot, this->schema, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.schema = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_code; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_leader; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_schema; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t GetEdgeResp::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("GetEdgeResp"); + xfer += prot_->serializedFieldSize("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::serializedSize(*prot_, this->code); + xfer += prot_->serializedFieldSize("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->leader); + xfer += prot_->serializedFieldSize("schema", apache::thrift::protocol::T_STRUCT, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::Schema>::serializedSize(*prot_, this->schema); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t GetEdgeResp::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("GetEdgeResp"); + xfer += prot_->serializedFieldSize("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::serializedSize(*prot_, this->code); + xfer += prot_->serializedFieldSize("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->leader); + xfer += prot_->serializedFieldSize("schema", apache::thrift::protocol::T_STRUCT, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::Schema>::serializedSize(*prot_, this->schema); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t GetEdgeResp::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("GetEdgeResp"); + xfer += prot_->writeFieldBegin("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::write(*prot_, this->code); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::write(*prot_, this->leader); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("schema", apache::thrift::protocol::T_STRUCT, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::Schema>::write(*prot_, this->schema); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void GetEdgeResp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t GetEdgeResp::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t GetEdgeResp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t GetEdgeResp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void GetEdgeResp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t GetEdgeResp::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t GetEdgeResp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t GetEdgeResp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void DropEdgeReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_space_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::readWithContext(*iprot, this->space_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.space_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_edge_name: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->edge_name, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.edge_name = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_BOOL))) { + goto _loop; + } +_readField_if_exists: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::readWithContext(*iprot, this->if_exists, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.if_exists = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_space_id; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_edge_name; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_BOOL))) { + goto _readField_if_exists; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t DropEdgeReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("DropEdgeReq"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("edge_name", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->edge_name); + xfer += prot_->serializedFieldSize("if_exists", apache::thrift::protocol::T_BOOL, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::serializedSize(*prot_, this->if_exists); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t DropEdgeReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("DropEdgeReq"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("edge_name", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->edge_name); + xfer += prot_->serializedFieldSize("if_exists", apache::thrift::protocol::T_BOOL, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::serializedSize(*prot_, this->if_exists); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t DropEdgeReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("DropEdgeReq"); + xfer += prot_->writeFieldBegin("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::write(*prot_, this->space_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("edge_name", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->edge_name); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("if_exists", apache::thrift::protocol::T_BOOL, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::write(*prot_, this->if_exists); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void DropEdgeReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t DropEdgeReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t DropEdgeReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t DropEdgeReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void DropEdgeReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t DropEdgeReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t DropEdgeReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t DropEdgeReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void ListEdgesReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_space_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::readWithContext(*iprot, this->space_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.space_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_space_id; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t ListEdgesReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ListEdgesReq"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ListEdgesReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ListEdgesReq"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ListEdgesReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("ListEdgesReq"); + xfer += prot_->writeFieldBegin("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::write(*prot_, this->space_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void ListEdgesReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t ListEdgesReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t ListEdgesReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t ListEdgesReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void ListEdgesReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t ListEdgesReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t ListEdgesReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t ListEdgesReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void ListEdgesResp::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_code: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::readWithContext(*iprot, this->code, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.code = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_leader: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::readWithContext(*iprot, this->leader, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.leader = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_edges: + { + _readState.beforeSubobject(iprot); + this->edges = ::std::vector< ::nebula::meta::cpp2::EdgeItem>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::EdgeItem>>::readWithContext(*iprot, this->edges, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.edges = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_code; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_leader; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_edges; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t ListEdgesResp::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ListEdgesResp"); + xfer += prot_->serializedFieldSize("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::serializedSize(*prot_, this->code); + xfer += prot_->serializedFieldSize("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->leader); + xfer += prot_->serializedFieldSize("edges", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::EdgeItem>>::serializedSize(*prot_, this->edges); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ListEdgesResp::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ListEdgesResp"); + xfer += prot_->serializedFieldSize("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::serializedSize(*prot_, this->code); + xfer += prot_->serializedFieldSize("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->leader); + xfer += prot_->serializedFieldSize("edges", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::EdgeItem>>::serializedSize(*prot_, this->edges); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ListEdgesResp::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("ListEdgesResp"); + xfer += prot_->writeFieldBegin("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::write(*prot_, this->code); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::write(*prot_, this->leader); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("edges", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::EdgeItem>>::write(*prot_, this->edges); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void ListEdgesResp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t ListEdgesResp::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t ListEdgesResp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t ListEdgesResp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void ListEdgesResp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t ListEdgesResp::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t ListEdgesResp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t ListEdgesResp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void ListHostsReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_type: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::ListHostType>::readWithContext(*iprot, this->type, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.type = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_type; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t ListHostsReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ListHostsReq"); + xfer += prot_->serializedFieldSize("type", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::ListHostType>::serializedSize(*prot_, this->type); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ListHostsReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ListHostsReq"); + xfer += prot_->serializedFieldSize("type", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::ListHostType>::serializedSize(*prot_, this->type); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ListHostsReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("ListHostsReq"); + xfer += prot_->writeFieldBegin("type", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::ListHostType>::write(*prot_, this->type); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void ListHostsReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t ListHostsReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t ListHostsReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t ListHostsReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void ListHostsReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t ListHostsReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t ListHostsReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t ListHostsReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void ListHostsResp::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_code: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::readWithContext(*iprot, this->code, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.code = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_leader: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::readWithContext(*iprot, this->leader, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.leader = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_hosts: + { + _readState.beforeSubobject(iprot); + this->hosts = ::std::vector< ::nebula::meta::cpp2::HostItem>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::HostItem>>::readWithContext(*iprot, this->hosts, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.hosts = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_code; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_leader; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_hosts; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t ListHostsResp::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ListHostsResp"); + xfer += prot_->serializedFieldSize("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::serializedSize(*prot_, this->code); + xfer += prot_->serializedFieldSize("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->leader); + xfer += prot_->serializedFieldSize("hosts", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::HostItem>>::serializedSize(*prot_, this->hosts); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ListHostsResp::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ListHostsResp"); + xfer += prot_->serializedFieldSize("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::serializedSize(*prot_, this->code); + xfer += prot_->serializedFieldSize("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->leader); + xfer += prot_->serializedFieldSize("hosts", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::HostItem>>::serializedSize(*prot_, this->hosts); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ListHostsResp::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("ListHostsResp"); + xfer += prot_->writeFieldBegin("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::write(*prot_, this->code); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::write(*prot_, this->leader); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("hosts", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::HostItem>>::write(*prot_, this->hosts); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void ListHostsResp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t ListHostsResp::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t ListHostsResp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t ListHostsResp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void ListHostsResp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t ListHostsResp::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t ListHostsResp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t ListHostsResp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void PartItem::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_part_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::PartitionID>::readWithContext(*iprot, this->part_id, _readState); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_leader: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::readWithContext(*iprot, this->leader, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.leader = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_peers: + { + _readState.beforeSubobject(iprot); + this->peers = ::std::vector(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector>::readWithContext(*iprot, this->peers, _readState); + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 4, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_losts: + { + _readState.beforeSubobject(iprot); + this->losts = ::std::vector(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector>::readWithContext(*iprot, this->losts, _readState); + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 4, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_part_id; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_leader; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_peers; + } else { + goto _skip; + } + } + case 4: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_losts; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t PartItem::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("PartItem"); + xfer += prot_->serializedFieldSize("part_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::PartitionID>::serializedSize(*prot_, this->part_id); + if (this->leader_ref().has_value()) { + xfer += prot_->serializedFieldSize("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->leader); + } + xfer += prot_->serializedFieldSize("peers", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector>::serializedSize(*prot_, this->peers); + xfer += prot_->serializedFieldSize("losts", apache::thrift::protocol::T_LIST, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector>::serializedSize(*prot_, this->losts); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t PartItem::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("PartItem"); + xfer += prot_->serializedFieldSize("part_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::PartitionID>::serializedSize(*prot_, this->part_id); + if (this->leader_ref().has_value()) { + xfer += prot_->serializedFieldSize("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->leader); + } + xfer += prot_->serializedFieldSize("peers", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector>::serializedSize(*prot_, this->peers); + xfer += prot_->serializedFieldSize("losts", apache::thrift::protocol::T_LIST, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector>::serializedSize(*prot_, this->losts); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t PartItem::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("PartItem"); + xfer += prot_->writeFieldBegin("part_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::PartitionID>::write(*prot_, this->part_id); + xfer += prot_->writeFieldEnd(); + if (this->leader_ref().has_value()) { + xfer += prot_->writeFieldBegin("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::write(*prot_, this->leader); + xfer += prot_->writeFieldEnd(); + } + xfer += prot_->writeFieldBegin("peers", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector>::write(*prot_, this->peers); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("losts", apache::thrift::protocol::T_LIST, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector>::write(*prot_, this->losts); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void PartItem::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t PartItem::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t PartItem::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t PartItem::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void PartItem::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t PartItem::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t PartItem::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t PartItem::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void ListPartsReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_space_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::readWithContext(*iprot, this->space_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.space_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_part_ids: + { + _readState.beforeSubobject(iprot); + this->part_ids = ::std::vector< ::nebula::cpp2::PartitionID>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::integral>, ::std::vector< ::nebula::cpp2::PartitionID>>::readWithContext(*iprot, this->part_ids, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.part_ids = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_space_id; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_part_ids; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t ListPartsReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ListPartsReq"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("part_ids", apache::thrift::protocol::T_LIST, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::integral>, ::std::vector< ::nebula::cpp2::PartitionID>>::serializedSize(*prot_, this->part_ids); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ListPartsReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ListPartsReq"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("part_ids", apache::thrift::protocol::T_LIST, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::integral>, ::std::vector< ::nebula::cpp2::PartitionID>>::serializedSize(*prot_, this->part_ids); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ListPartsReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("ListPartsReq"); + xfer += prot_->writeFieldBegin("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::write(*prot_, this->space_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("part_ids", apache::thrift::protocol::T_LIST, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::integral>, ::std::vector< ::nebula::cpp2::PartitionID>>::write(*prot_, this->part_ids); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void ListPartsReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t ListPartsReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t ListPartsReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t ListPartsReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void ListPartsReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t ListPartsReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t ListPartsReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t ListPartsReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void ListPartsResp::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_code: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::readWithContext(*iprot, this->code, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.code = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_leader: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::readWithContext(*iprot, this->leader, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.leader = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_parts: + { + _readState.beforeSubobject(iprot); + this->parts = ::std::vector< ::nebula::meta::cpp2::PartItem>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::PartItem>>::readWithContext(*iprot, this->parts, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.parts = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_code; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_leader; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_parts; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t ListPartsResp::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ListPartsResp"); + xfer += prot_->serializedFieldSize("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::serializedSize(*prot_, this->code); + xfer += prot_->serializedFieldSize("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->leader); + xfer += prot_->serializedFieldSize("parts", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::PartItem>>::serializedSize(*prot_, this->parts); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ListPartsResp::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ListPartsResp"); + xfer += prot_->serializedFieldSize("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::serializedSize(*prot_, this->code); + xfer += prot_->serializedFieldSize("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->leader); + xfer += prot_->serializedFieldSize("parts", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::PartItem>>::serializedSize(*prot_, this->parts); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ListPartsResp::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("ListPartsResp"); + xfer += prot_->writeFieldBegin("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::write(*prot_, this->code); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::write(*prot_, this->leader); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("parts", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::PartItem>>::write(*prot_, this->parts); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void ListPartsResp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t ListPartsResp::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t ListPartsResp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t ListPartsResp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void ListPartsResp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t ListPartsResp::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t ListPartsResp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t ListPartsResp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void GetPartsAllocReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_space_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::readWithContext(*iprot, this->space_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.space_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_space_id; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t GetPartsAllocReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("GetPartsAllocReq"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t GetPartsAllocReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("GetPartsAllocReq"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t GetPartsAllocReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("GetPartsAllocReq"); + xfer += prot_->writeFieldBegin("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::write(*prot_, this->space_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void GetPartsAllocReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t GetPartsAllocReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t GetPartsAllocReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t GetPartsAllocReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void GetPartsAllocReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t GetPartsAllocReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t GetPartsAllocReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t GetPartsAllocReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void GetPartsAllocResp::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_code: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::readWithContext(*iprot, this->code, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.code = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_leader: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::readWithContext(*iprot, this->leader, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.leader = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_MAP))) { + goto _loop; + } +_readField_parts: + { + _readState.beforeSubobject(iprot); + this->parts = std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>>, std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector>>::readWithContext(*iprot, this->parts, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.parts = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 4, + apache::thrift::protocol::T_MAP))) { + goto _loop; + } +_readField_terms: + { + _readState.beforeSubobject(iprot); + this->terms = std::unordered_map< ::nebula::cpp2::PartitionID, int64_t>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::integral>, std::unordered_map< ::nebula::cpp2::PartitionID, int64_t>>::readWithContext(*iprot, this->terms, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.terms = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 4, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_code; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_leader; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_MAP))) { + goto _readField_parts; + } else { + goto _skip; + } + } + case 4: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_MAP))) { + goto _readField_terms; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t GetPartsAllocResp::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("GetPartsAllocResp"); + xfer += prot_->serializedFieldSize("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::serializedSize(*prot_, this->code); + xfer += prot_->serializedFieldSize("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->leader); + xfer += prot_->serializedFieldSize("parts", apache::thrift::protocol::T_MAP, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>>, std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector>>::serializedSize(*prot_, this->parts); + if (this->terms_ref().has_value()) { + xfer += prot_->serializedFieldSize("terms", apache::thrift::protocol::T_MAP, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::integral>, std::unordered_map< ::nebula::cpp2::PartitionID, int64_t>>::serializedSize(*prot_, this->terms); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t GetPartsAllocResp::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("GetPartsAllocResp"); + xfer += prot_->serializedFieldSize("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::serializedSize(*prot_, this->code); + xfer += prot_->serializedFieldSize("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->leader); + xfer += prot_->serializedFieldSize("parts", apache::thrift::protocol::T_MAP, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>>, std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector>>::serializedSize(*prot_, this->parts); + if (this->terms_ref().has_value()) { + xfer += prot_->serializedFieldSize("terms", apache::thrift::protocol::T_MAP, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::integral>, std::unordered_map< ::nebula::cpp2::PartitionID, int64_t>>::serializedSize(*prot_, this->terms); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t GetPartsAllocResp::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("GetPartsAllocResp"); + xfer += prot_->writeFieldBegin("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::write(*prot_, this->code); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::write(*prot_, this->leader); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("parts", apache::thrift::protocol::T_MAP, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>>, std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector>>::write(*prot_, this->parts); + xfer += prot_->writeFieldEnd(); + if (this->terms_ref().has_value()) { + xfer += prot_->writeFieldBegin("terms", apache::thrift::protocol::T_MAP, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::integral>, std::unordered_map< ::nebula::cpp2::PartitionID, int64_t>>::write(*prot_, this->terms); + xfer += prot_->writeFieldEnd(); + } + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void GetPartsAllocResp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t GetPartsAllocResp::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t GetPartsAllocResp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t GetPartsAllocResp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void GetPartsAllocResp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t GetPartsAllocResp::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t GetPartsAllocResp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t GetPartsAllocResp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void MultiPutReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_segment: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->segment, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.segment = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_pairs: + { + _readState.beforeSubobject(iprot); + this->pairs = ::std::vector(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector>::readWithContext(*iprot, this->pairs, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.pairs = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_segment; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_pairs; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t MultiPutReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("MultiPutReq"); + xfer += prot_->serializedFieldSize("segment", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->segment); + xfer += prot_->serializedFieldSize("pairs", apache::thrift::protocol::T_LIST, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector>::serializedSize(*prot_, this->pairs); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t MultiPutReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("MultiPutReq"); + xfer += prot_->serializedFieldSize("segment", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->segment); + xfer += prot_->serializedFieldSize("pairs", apache::thrift::protocol::T_LIST, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector>::serializedSize(*prot_, this->pairs); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t MultiPutReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("MultiPutReq"); + xfer += prot_->writeFieldBegin("segment", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->segment); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("pairs", apache::thrift::protocol::T_LIST, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector>::write(*prot_, this->pairs); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void MultiPutReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t MultiPutReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t MultiPutReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t MultiPutReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void MultiPutReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t MultiPutReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t MultiPutReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t MultiPutReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void GetReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_segment: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->segment, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.segment = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_key: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->key, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.key = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_segment; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_key; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t GetReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("GetReq"); + xfer += prot_->serializedFieldSize("segment", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->segment); + xfer += prot_->serializedFieldSize("key", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->key); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t GetReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("GetReq"); + xfer += prot_->serializedFieldSize("segment", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->segment); + xfer += prot_->serializedFieldSize("key", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->key); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t GetReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("GetReq"); + xfer += prot_->writeFieldBegin("segment", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->segment); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("key", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->key); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void GetReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t GetReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t GetReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t GetReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void GetReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t GetReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t GetReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t GetReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void GetResp::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_code: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::readWithContext(*iprot, this->code, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.code = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_leader: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::readWithContext(*iprot, this->leader, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.leader = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_value: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->value, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.value = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_code; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_leader; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_value; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t GetResp::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("GetResp"); + xfer += prot_->serializedFieldSize("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::serializedSize(*prot_, this->code); + xfer += prot_->serializedFieldSize("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->leader); + xfer += prot_->serializedFieldSize("value", apache::thrift::protocol::T_STRING, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->value); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t GetResp::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("GetResp"); + xfer += prot_->serializedFieldSize("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::serializedSize(*prot_, this->code); + xfer += prot_->serializedFieldSize("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->leader); + xfer += prot_->serializedFieldSize("value", apache::thrift::protocol::T_STRING, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->value); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t GetResp::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("GetResp"); + xfer += prot_->writeFieldBegin("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::write(*prot_, this->code); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::write(*prot_, this->leader); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("value", apache::thrift::protocol::T_STRING, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->value); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void GetResp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t GetResp::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t GetResp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t GetResp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void GetResp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t GetResp::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t GetResp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t GetResp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void MultiGetReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_segment: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->segment, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.segment = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_keys: + { + _readState.beforeSubobject(iprot); + this->keys = ::std::vector<::std::string>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>, ::std::vector<::std::string>>::readWithContext(*iprot, this->keys, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.keys = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_segment; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_keys; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t MultiGetReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("MultiGetReq"); + xfer += prot_->serializedFieldSize("segment", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->segment); + xfer += prot_->serializedFieldSize("keys", apache::thrift::protocol::T_LIST, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>, ::std::vector<::std::string>>::serializedSize(*prot_, this->keys); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t MultiGetReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("MultiGetReq"); + xfer += prot_->serializedFieldSize("segment", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->segment); + xfer += prot_->serializedFieldSize("keys", apache::thrift::protocol::T_LIST, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>, ::std::vector<::std::string>>::serializedSize(*prot_, this->keys); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t MultiGetReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("MultiGetReq"); + xfer += prot_->writeFieldBegin("segment", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->segment); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("keys", apache::thrift::protocol::T_LIST, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>, ::std::vector<::std::string>>::write(*prot_, this->keys); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void MultiGetReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t MultiGetReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t MultiGetReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t MultiGetReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void MultiGetReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t MultiGetReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t MultiGetReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t MultiGetReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void MultiGetResp::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_code: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::readWithContext(*iprot, this->code, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.code = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_leader: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::readWithContext(*iprot, this->leader, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.leader = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_values: + { + _readState.beforeSubobject(iprot); + this->values = ::std::vector<::std::string>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>, ::std::vector<::std::string>>::readWithContext(*iprot, this->values, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.values = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_code; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_leader; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_values; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t MultiGetResp::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("MultiGetResp"); + xfer += prot_->serializedFieldSize("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::serializedSize(*prot_, this->code); + xfer += prot_->serializedFieldSize("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->leader); + xfer += prot_->serializedFieldSize("values", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>, ::std::vector<::std::string>>::serializedSize(*prot_, this->values); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t MultiGetResp::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("MultiGetResp"); + xfer += prot_->serializedFieldSize("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::serializedSize(*prot_, this->code); + xfer += prot_->serializedFieldSize("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->leader); + xfer += prot_->serializedFieldSize("values", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>, ::std::vector<::std::string>>::serializedSize(*prot_, this->values); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t MultiGetResp::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("MultiGetResp"); + xfer += prot_->writeFieldBegin("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::write(*prot_, this->code); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::write(*prot_, this->leader); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("values", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>, ::std::vector<::std::string>>::write(*prot_, this->values); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void MultiGetResp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t MultiGetResp::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t MultiGetResp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t MultiGetResp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void MultiGetResp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t MultiGetResp::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t MultiGetResp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t MultiGetResp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void RemoveReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_segment: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->segment, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.segment = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_key: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->key, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.key = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_segment; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_key; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t RemoveReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("RemoveReq"); + xfer += prot_->serializedFieldSize("segment", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->segment); + xfer += prot_->serializedFieldSize("key", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->key); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t RemoveReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("RemoveReq"); + xfer += prot_->serializedFieldSize("segment", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->segment); + xfer += prot_->serializedFieldSize("key", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->key); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t RemoveReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("RemoveReq"); + xfer += prot_->writeFieldBegin("segment", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->segment); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("key", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->key); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void RemoveReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t RemoveReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t RemoveReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t RemoveReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void RemoveReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t RemoveReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t RemoveReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t RemoveReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void RemoveRangeReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_segment: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->segment, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.segment = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_start: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->start, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.start = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_end: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->end, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.end = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_segment; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_start; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_end; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t RemoveRangeReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("RemoveRangeReq"); + xfer += prot_->serializedFieldSize("segment", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->segment); + xfer += prot_->serializedFieldSize("start", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->start); + xfer += prot_->serializedFieldSize("end", apache::thrift::protocol::T_STRING, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->end); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t RemoveRangeReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("RemoveRangeReq"); + xfer += prot_->serializedFieldSize("segment", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->segment); + xfer += prot_->serializedFieldSize("start", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->start); + xfer += prot_->serializedFieldSize("end", apache::thrift::protocol::T_STRING, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->end); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t RemoveRangeReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("RemoveRangeReq"); + xfer += prot_->writeFieldBegin("segment", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->segment); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("start", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->start); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("end", apache::thrift::protocol::T_STRING, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->end); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void RemoveRangeReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t RemoveRangeReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t RemoveRangeReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t RemoveRangeReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void RemoveRangeReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t RemoveRangeReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t RemoveRangeReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t RemoveRangeReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void ScanReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_segment: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->segment, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.segment = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_start: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->start, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.start = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_end: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->end, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.end = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_segment; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_start; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_end; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t ScanReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ScanReq"); + xfer += prot_->serializedFieldSize("segment", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->segment); + xfer += prot_->serializedFieldSize("start", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->start); + xfer += prot_->serializedFieldSize("end", apache::thrift::protocol::T_STRING, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->end); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ScanReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ScanReq"); + xfer += prot_->serializedFieldSize("segment", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->segment); + xfer += prot_->serializedFieldSize("start", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->start); + xfer += prot_->serializedFieldSize("end", apache::thrift::protocol::T_STRING, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->end); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ScanReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("ScanReq"); + xfer += prot_->writeFieldBegin("segment", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->segment); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("start", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->start); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("end", apache::thrift::protocol::T_STRING, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->end); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void ScanReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t ScanReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t ScanReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t ScanReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void ScanReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t ScanReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t ScanReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t ScanReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void ScanResp::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_code: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::readWithContext(*iprot, this->code, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.code = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_leader: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::readWithContext(*iprot, this->leader, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.leader = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_values: + { + _readState.beforeSubobject(iprot); + this->values = ::std::vector<::std::string>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>, ::std::vector<::std::string>>::readWithContext(*iprot, this->values, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.values = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_code; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_leader; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_values; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t ScanResp::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ScanResp"); + xfer += prot_->serializedFieldSize("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::serializedSize(*prot_, this->code); + xfer += prot_->serializedFieldSize("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->leader); + xfer += prot_->serializedFieldSize("values", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>, ::std::vector<::std::string>>::serializedSize(*prot_, this->values); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ScanResp::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ScanResp"); + xfer += prot_->serializedFieldSize("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::serializedSize(*prot_, this->code); + xfer += prot_->serializedFieldSize("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->leader); + xfer += prot_->serializedFieldSize("values", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>, ::std::vector<::std::string>>::serializedSize(*prot_, this->values); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ScanResp::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("ScanResp"); + xfer += prot_->writeFieldBegin("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::write(*prot_, this->code); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::write(*prot_, this->leader); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("values", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>, ::std::vector<::std::string>>::write(*prot_, this->values); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void ScanResp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t ScanResp::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t ScanResp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t ScanResp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void ScanResp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t ScanResp::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t ScanResp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t ScanResp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void HBResp::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_code: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::readWithContext(*iprot, this->code, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.code = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_leader: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::readWithContext(*iprot, this->leader, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.leader = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_I64))) { + goto _loop; + } +_readField_cluster_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::meta::cpp2::ClusterID>::readWithContext(*iprot, this->cluster_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.cluster_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 4, + apache::thrift::protocol::T_I64))) { + goto _loop; + } +_readField_last_update_time_in_ms: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::readWithContext(*iprot, this->last_update_time_in_ms, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.last_update_time_in_ms = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 4, + 5, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_meta_version: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::readWithContext(*iprot, this->meta_version, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.meta_version = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 5, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_code; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_leader; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I64))) { + goto _readField_cluster_id; + } else { + goto _skip; + } + } + case 4: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I64))) { + goto _readField_last_update_time_in_ms; + } else { + goto _skip; + } + } + case 5: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_meta_version; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t HBResp::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("HBResp"); + xfer += prot_->serializedFieldSize("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::serializedSize(*prot_, this->code); + xfer += prot_->serializedFieldSize("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->leader); + xfer += prot_->serializedFieldSize("cluster_id", apache::thrift::protocol::T_I64, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::meta::cpp2::ClusterID>::serializedSize(*prot_, this->cluster_id); + xfer += prot_->serializedFieldSize("last_update_time_in_ms", apache::thrift::protocol::T_I64, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::serializedSize(*prot_, this->last_update_time_in_ms); + xfer += prot_->serializedFieldSize("meta_version", apache::thrift::protocol::T_I32, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::serializedSize(*prot_, this->meta_version); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t HBResp::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("HBResp"); + xfer += prot_->serializedFieldSize("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::serializedSize(*prot_, this->code); + xfer += prot_->serializedFieldSize("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->leader); + xfer += prot_->serializedFieldSize("cluster_id", apache::thrift::protocol::T_I64, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::meta::cpp2::ClusterID>::serializedSize(*prot_, this->cluster_id); + xfer += prot_->serializedFieldSize("last_update_time_in_ms", apache::thrift::protocol::T_I64, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::serializedSize(*prot_, this->last_update_time_in_ms); + xfer += prot_->serializedFieldSize("meta_version", apache::thrift::protocol::T_I32, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::serializedSize(*prot_, this->meta_version); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t HBResp::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("HBResp"); + xfer += prot_->writeFieldBegin("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::write(*prot_, this->code); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::write(*prot_, this->leader); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("cluster_id", apache::thrift::protocol::T_I64, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::meta::cpp2::ClusterID>::write(*prot_, this->cluster_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("last_update_time_in_ms", apache::thrift::protocol::T_I64, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::write(*prot_, this->last_update_time_in_ms); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("meta_version", apache::thrift::protocol::T_I32, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::write(*prot_, this->meta_version); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void HBResp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t HBResp::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t HBResp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t HBResp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void HBResp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t HBResp::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t HBResp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t HBResp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void LeaderInfo::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_part_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::PartitionID>::readWithContext(*iprot, this->part_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.part_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_I64))) { + goto _loop; + } +_readField_term: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::readWithContext(*iprot, this->term, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.term = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_part_id; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I64))) { + goto _readField_term; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t LeaderInfo::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("LeaderInfo"); + xfer += prot_->serializedFieldSize("part_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::PartitionID>::serializedSize(*prot_, this->part_id); + xfer += prot_->serializedFieldSize("term", apache::thrift::protocol::T_I64, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::serializedSize(*prot_, this->term); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t LeaderInfo::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("LeaderInfo"); + xfer += prot_->serializedFieldSize("part_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::PartitionID>::serializedSize(*prot_, this->part_id); + xfer += prot_->serializedFieldSize("term", apache::thrift::protocol::T_I64, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::serializedSize(*prot_, this->term); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t LeaderInfo::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("LeaderInfo"); + xfer += prot_->writeFieldBegin("part_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::PartitionID>::write(*prot_, this->part_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("term", apache::thrift::protocol::T_I64, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::write(*prot_, this->term); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void LeaderInfo::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t LeaderInfo::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t LeaderInfo::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t LeaderInfo::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void LeaderInfo::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t LeaderInfo::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t LeaderInfo::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t LeaderInfo::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void HBReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_role: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::HostRole>::readWithContext(*iprot, this->role, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.role = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_host: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::readWithContext(*iprot, this->host, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.host = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_I64))) { + goto _loop; + } +_readField_cluster_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::meta::cpp2::ClusterID>::readWithContext(*iprot, this->cluster_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.cluster_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 4, + apache::thrift::protocol::T_MAP))) { + goto _loop; + } +_readField_leader_partIds: + { + _readState.beforeSubobject(iprot); + this->leader_partIds = std::unordered_map< ::nebula::cpp2::GraphSpaceID, ::std::vector< ::nebula::meta::cpp2::LeaderInfo>>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>>, std::unordered_map< ::nebula::cpp2::GraphSpaceID, ::std::vector< ::nebula::meta::cpp2::LeaderInfo>>>::readWithContext(*iprot, this->leader_partIds, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.leader_partIds = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 4, + 5, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_git_info_sha: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->git_info_sha, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.git_info_sha = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 5, + 6, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_version: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->version, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.version = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 6, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_role; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_host; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I64))) { + goto _readField_cluster_id; + } else { + goto _skip; + } + } + case 4: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_MAP))) { + goto _readField_leader_partIds; + } else { + goto _skip; + } + } + case 5: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_git_info_sha; + } else { + goto _skip; + } + } + case 6: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_version; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t HBReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("HBReq"); + xfer += prot_->serializedFieldSize("role", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::HostRole>::serializedSize(*prot_, this->role); + xfer += prot_->serializedFieldSize("host", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->host); + xfer += prot_->serializedFieldSize("cluster_id", apache::thrift::protocol::T_I64, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::meta::cpp2::ClusterID>::serializedSize(*prot_, this->cluster_id); + if (this->leader_partIds_ref().has_value()) { + xfer += prot_->serializedFieldSize("leader_partIds", apache::thrift::protocol::T_MAP, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>>, std::unordered_map< ::nebula::cpp2::GraphSpaceID, ::std::vector< ::nebula::meta::cpp2::LeaderInfo>>>::serializedSize(*prot_, this->leader_partIds); + } + xfer += prot_->serializedFieldSize("git_info_sha", apache::thrift::protocol::T_STRING, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->git_info_sha); + if (this->version_ref().has_value()) { + xfer += prot_->serializedFieldSize("version", apache::thrift::protocol::T_STRING, 6); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->version); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t HBReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("HBReq"); + xfer += prot_->serializedFieldSize("role", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::HostRole>::serializedSize(*prot_, this->role); + xfer += prot_->serializedFieldSize("host", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->host); + xfer += prot_->serializedFieldSize("cluster_id", apache::thrift::protocol::T_I64, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::meta::cpp2::ClusterID>::serializedSize(*prot_, this->cluster_id); + if (this->leader_partIds_ref().has_value()) { + xfer += prot_->serializedFieldSize("leader_partIds", apache::thrift::protocol::T_MAP, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>>, std::unordered_map< ::nebula::cpp2::GraphSpaceID, ::std::vector< ::nebula::meta::cpp2::LeaderInfo>>>::serializedSize(*prot_, this->leader_partIds); + } + xfer += prot_->serializedFieldSize("git_info_sha", apache::thrift::protocol::T_STRING, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->git_info_sha); + if (this->version_ref().has_value()) { + xfer += prot_->serializedFieldSize("version", apache::thrift::protocol::T_STRING, 6); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->version); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t HBReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("HBReq"); + xfer += prot_->writeFieldBegin("role", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::HostRole>::write(*prot_, this->role); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("host", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::write(*prot_, this->host); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("cluster_id", apache::thrift::protocol::T_I64, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::meta::cpp2::ClusterID>::write(*prot_, this->cluster_id); + xfer += prot_->writeFieldEnd(); + if (this->leader_partIds_ref().has_value()) { + xfer += prot_->writeFieldBegin("leader_partIds", apache::thrift::protocol::T_MAP, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>>, std::unordered_map< ::nebula::cpp2::GraphSpaceID, ::std::vector< ::nebula::meta::cpp2::LeaderInfo>>>::write(*prot_, this->leader_partIds); + xfer += prot_->writeFieldEnd(); + } + xfer += prot_->writeFieldBegin("git_info_sha", apache::thrift::protocol::T_STRING, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->git_info_sha); + xfer += prot_->writeFieldEnd(); + if (this->version_ref().has_value()) { + xfer += prot_->writeFieldBegin("version", apache::thrift::protocol::T_STRING, 6); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->version); + xfer += prot_->writeFieldEnd(); + } + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void HBReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t HBReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t HBReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t HBReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void HBReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t HBReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t HBReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t HBReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void IndexFieldDef::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_name: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->name, _readState); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_I16))) { + goto _loop; + } +_readField_type_length: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int16_t>::readWithContext(*iprot, this->type_length, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.type_length = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_name; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I16))) { + goto _readField_type_length; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t IndexFieldDef::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("IndexFieldDef"); + xfer += prot_->serializedFieldSize("name", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->name); + if (this->type_length_ref().has_value()) { + xfer += prot_->serializedFieldSize("type_length", apache::thrift::protocol::T_I16, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int16_t>::serializedSize(*prot_, this->type_length); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t IndexFieldDef::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("IndexFieldDef"); + xfer += prot_->serializedFieldSize("name", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->name); + if (this->type_length_ref().has_value()) { + xfer += prot_->serializedFieldSize("type_length", apache::thrift::protocol::T_I16, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int16_t>::serializedSize(*prot_, this->type_length); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t IndexFieldDef::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("IndexFieldDef"); + xfer += prot_->writeFieldBegin("name", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->name); + xfer += prot_->writeFieldEnd(); + if (this->type_length_ref().has_value()) { + xfer += prot_->writeFieldBegin("type_length", apache::thrift::protocol::T_I16, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int16_t>::write(*prot_, this->type_length); + xfer += prot_->writeFieldEnd(); + } + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void IndexFieldDef::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t IndexFieldDef::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t IndexFieldDef::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t IndexFieldDef::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void IndexFieldDef::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t IndexFieldDef::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t IndexFieldDef::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t IndexFieldDef::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void CreateTagIndexReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_space_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::readWithContext(*iprot, this->space_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.space_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_index_name: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->index_name, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.index_name = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_tag_name: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->tag_name, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.tag_name = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 4, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_fields: + { + _readState.beforeSubobject(iprot); + this->fields = ::std::vector< ::nebula::meta::cpp2::IndexFieldDef>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::IndexFieldDef>>::readWithContext(*iprot, this->fields, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.fields = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 4, + 5, + apache::thrift::protocol::T_BOOL))) { + goto _loop; + } +_readField_if_not_exists: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::readWithContext(*iprot, this->if_not_exists, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.if_not_exists = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 5, + 6, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_comment: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->comment, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.comment = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 6, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_space_id; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_index_name; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_tag_name; + } else { + goto _skip; + } + } + case 4: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_fields; + } else { + goto _skip; + } + } + case 5: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_BOOL))) { + goto _readField_if_not_exists; + } else { + goto _skip; + } + } + case 6: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_comment; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t CreateTagIndexReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("CreateTagIndexReq"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("index_name", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->index_name); + xfer += prot_->serializedFieldSize("tag_name", apache::thrift::protocol::T_STRING, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->tag_name); + xfer += prot_->serializedFieldSize("fields", apache::thrift::protocol::T_LIST, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::IndexFieldDef>>::serializedSize(*prot_, this->fields); + xfer += prot_->serializedFieldSize("if_not_exists", apache::thrift::protocol::T_BOOL, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::serializedSize(*prot_, this->if_not_exists); + if (this->comment_ref().has_value()) { + xfer += prot_->serializedFieldSize("comment", apache::thrift::protocol::T_STRING, 6); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->comment); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t CreateTagIndexReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("CreateTagIndexReq"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("index_name", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->index_name); + xfer += prot_->serializedFieldSize("tag_name", apache::thrift::protocol::T_STRING, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->tag_name); + xfer += prot_->serializedFieldSize("fields", apache::thrift::protocol::T_LIST, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::IndexFieldDef>>::serializedSize(*prot_, this->fields); + xfer += prot_->serializedFieldSize("if_not_exists", apache::thrift::protocol::T_BOOL, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::serializedSize(*prot_, this->if_not_exists); + if (this->comment_ref().has_value()) { + xfer += prot_->serializedFieldSize("comment", apache::thrift::protocol::T_STRING, 6); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->comment); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t CreateTagIndexReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("CreateTagIndexReq"); + xfer += prot_->writeFieldBegin("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::write(*prot_, this->space_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("index_name", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->index_name); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("tag_name", apache::thrift::protocol::T_STRING, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->tag_name); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("fields", apache::thrift::protocol::T_LIST, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::IndexFieldDef>>::write(*prot_, this->fields); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("if_not_exists", apache::thrift::protocol::T_BOOL, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::write(*prot_, this->if_not_exists); + xfer += prot_->writeFieldEnd(); + if (this->comment_ref().has_value()) { + xfer += prot_->writeFieldBegin("comment", apache::thrift::protocol::T_STRING, 6); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->comment); + xfer += prot_->writeFieldEnd(); + } + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void CreateTagIndexReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t CreateTagIndexReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t CreateTagIndexReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t CreateTagIndexReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void CreateTagIndexReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t CreateTagIndexReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t CreateTagIndexReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t CreateTagIndexReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void DropTagIndexReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_space_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::readWithContext(*iprot, this->space_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.space_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_index_name: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->index_name, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.index_name = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_BOOL))) { + goto _loop; + } +_readField_if_exists: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::readWithContext(*iprot, this->if_exists, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.if_exists = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_space_id; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_index_name; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_BOOL))) { + goto _readField_if_exists; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t DropTagIndexReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("DropTagIndexReq"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("index_name", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->index_name); + xfer += prot_->serializedFieldSize("if_exists", apache::thrift::protocol::T_BOOL, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::serializedSize(*prot_, this->if_exists); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t DropTagIndexReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("DropTagIndexReq"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("index_name", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->index_name); + xfer += prot_->serializedFieldSize("if_exists", apache::thrift::protocol::T_BOOL, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::serializedSize(*prot_, this->if_exists); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t DropTagIndexReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("DropTagIndexReq"); + xfer += prot_->writeFieldBegin("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::write(*prot_, this->space_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("index_name", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->index_name); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("if_exists", apache::thrift::protocol::T_BOOL, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::write(*prot_, this->if_exists); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void DropTagIndexReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t DropTagIndexReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t DropTagIndexReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t DropTagIndexReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void DropTagIndexReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t DropTagIndexReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t DropTagIndexReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t DropTagIndexReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void GetTagIndexReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_space_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::readWithContext(*iprot, this->space_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.space_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_index_name: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->index_name, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.index_name = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_space_id; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_index_name; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t GetTagIndexReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("GetTagIndexReq"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("index_name", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->index_name); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t GetTagIndexReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("GetTagIndexReq"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("index_name", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->index_name); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t GetTagIndexReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("GetTagIndexReq"); + xfer += prot_->writeFieldBegin("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::write(*prot_, this->space_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("index_name", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->index_name); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void GetTagIndexReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t GetTagIndexReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t GetTagIndexReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t GetTagIndexReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void GetTagIndexReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t GetTagIndexReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t GetTagIndexReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t GetTagIndexReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void GetTagIndexResp::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_code: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::readWithContext(*iprot, this->code, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.code = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_leader: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::readWithContext(*iprot, this->leader, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.leader = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_item: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::IndexItem>::readWithContext(*iprot, this->item, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.item = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_code; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_leader; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_item; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t GetTagIndexResp::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("GetTagIndexResp"); + xfer += prot_->serializedFieldSize("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::serializedSize(*prot_, this->code); + xfer += prot_->serializedFieldSize("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->leader); + xfer += prot_->serializedFieldSize("item", apache::thrift::protocol::T_STRUCT, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::IndexItem>::serializedSize(*prot_, this->item); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t GetTagIndexResp::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("GetTagIndexResp"); + xfer += prot_->serializedFieldSize("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::serializedSize(*prot_, this->code); + xfer += prot_->serializedFieldSize("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->leader); + xfer += prot_->serializedFieldSize("item", apache::thrift::protocol::T_STRUCT, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::IndexItem>::serializedSize(*prot_, this->item); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t GetTagIndexResp::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("GetTagIndexResp"); + xfer += prot_->writeFieldBegin("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::write(*prot_, this->code); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::write(*prot_, this->leader); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("item", apache::thrift::protocol::T_STRUCT, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::IndexItem>::write(*prot_, this->item); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void GetTagIndexResp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t GetTagIndexResp::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t GetTagIndexResp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t GetTagIndexResp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void GetTagIndexResp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t GetTagIndexResp::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t GetTagIndexResp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t GetTagIndexResp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void ListTagIndexesReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_space_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::readWithContext(*iprot, this->space_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.space_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_space_id; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t ListTagIndexesReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ListTagIndexesReq"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ListTagIndexesReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ListTagIndexesReq"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ListTagIndexesReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("ListTagIndexesReq"); + xfer += prot_->writeFieldBegin("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::write(*prot_, this->space_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void ListTagIndexesReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t ListTagIndexesReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t ListTagIndexesReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t ListTagIndexesReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void ListTagIndexesReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t ListTagIndexesReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t ListTagIndexesReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t ListTagIndexesReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void ListTagIndexesResp::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_code: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::readWithContext(*iprot, this->code, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.code = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_leader: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::readWithContext(*iprot, this->leader, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.leader = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_items: + { + _readState.beforeSubobject(iprot); + this->items = ::std::vector< ::nebula::meta::cpp2::IndexItem>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::IndexItem>>::readWithContext(*iprot, this->items, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.items = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_code; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_leader; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_items; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t ListTagIndexesResp::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ListTagIndexesResp"); + xfer += prot_->serializedFieldSize("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::serializedSize(*prot_, this->code); + xfer += prot_->serializedFieldSize("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->leader); + xfer += prot_->serializedFieldSize("items", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::IndexItem>>::serializedSize(*prot_, this->items); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ListTagIndexesResp::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ListTagIndexesResp"); + xfer += prot_->serializedFieldSize("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::serializedSize(*prot_, this->code); + xfer += prot_->serializedFieldSize("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->leader); + xfer += prot_->serializedFieldSize("items", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::IndexItem>>::serializedSize(*prot_, this->items); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ListTagIndexesResp::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("ListTagIndexesResp"); + xfer += prot_->writeFieldBegin("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::write(*prot_, this->code); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::write(*prot_, this->leader); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("items", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::IndexItem>>::write(*prot_, this->items); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void ListTagIndexesResp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t ListTagIndexesResp::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t ListTagIndexesResp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t ListTagIndexesResp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void ListTagIndexesResp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t ListTagIndexesResp::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t ListTagIndexesResp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t ListTagIndexesResp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void CreateEdgeIndexReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_space_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::readWithContext(*iprot, this->space_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.space_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_index_name: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->index_name, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.index_name = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_edge_name: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->edge_name, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.edge_name = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 4, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_fields: + { + _readState.beforeSubobject(iprot); + this->fields = ::std::vector< ::nebula::meta::cpp2::IndexFieldDef>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::IndexFieldDef>>::readWithContext(*iprot, this->fields, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.fields = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 4, + 5, + apache::thrift::protocol::T_BOOL))) { + goto _loop; + } +_readField_if_not_exists: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::readWithContext(*iprot, this->if_not_exists, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.if_not_exists = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 5, + 6, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_comment: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->comment, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.comment = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 6, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_space_id; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_index_name; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_edge_name; + } else { + goto _skip; + } + } + case 4: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_fields; + } else { + goto _skip; + } + } + case 5: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_BOOL))) { + goto _readField_if_not_exists; + } else { + goto _skip; + } + } + case 6: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_comment; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t CreateEdgeIndexReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("CreateEdgeIndexReq"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("index_name", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->index_name); + xfer += prot_->serializedFieldSize("edge_name", apache::thrift::protocol::T_STRING, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->edge_name); + xfer += prot_->serializedFieldSize("fields", apache::thrift::protocol::T_LIST, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::IndexFieldDef>>::serializedSize(*prot_, this->fields); + xfer += prot_->serializedFieldSize("if_not_exists", apache::thrift::protocol::T_BOOL, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::serializedSize(*prot_, this->if_not_exists); + if (this->comment_ref().has_value()) { + xfer += prot_->serializedFieldSize("comment", apache::thrift::protocol::T_STRING, 6); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->comment); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t CreateEdgeIndexReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("CreateEdgeIndexReq"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("index_name", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->index_name); + xfer += prot_->serializedFieldSize("edge_name", apache::thrift::protocol::T_STRING, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->edge_name); + xfer += prot_->serializedFieldSize("fields", apache::thrift::protocol::T_LIST, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::IndexFieldDef>>::serializedSize(*prot_, this->fields); + xfer += prot_->serializedFieldSize("if_not_exists", apache::thrift::protocol::T_BOOL, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::serializedSize(*prot_, this->if_not_exists); + if (this->comment_ref().has_value()) { + xfer += prot_->serializedFieldSize("comment", apache::thrift::protocol::T_STRING, 6); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->comment); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t CreateEdgeIndexReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("CreateEdgeIndexReq"); + xfer += prot_->writeFieldBegin("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::write(*prot_, this->space_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("index_name", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->index_name); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("edge_name", apache::thrift::protocol::T_STRING, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->edge_name); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("fields", apache::thrift::protocol::T_LIST, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::IndexFieldDef>>::write(*prot_, this->fields); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("if_not_exists", apache::thrift::protocol::T_BOOL, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::write(*prot_, this->if_not_exists); + xfer += prot_->writeFieldEnd(); + if (this->comment_ref().has_value()) { + xfer += prot_->writeFieldBegin("comment", apache::thrift::protocol::T_STRING, 6); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->comment); + xfer += prot_->writeFieldEnd(); + } + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void CreateEdgeIndexReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t CreateEdgeIndexReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t CreateEdgeIndexReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t CreateEdgeIndexReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void CreateEdgeIndexReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t CreateEdgeIndexReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t CreateEdgeIndexReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t CreateEdgeIndexReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void DropEdgeIndexReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_space_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::readWithContext(*iprot, this->space_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.space_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_index_name: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->index_name, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.index_name = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_BOOL))) { + goto _loop; + } +_readField_if_exists: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::readWithContext(*iprot, this->if_exists, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.if_exists = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_space_id; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_index_name; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_BOOL))) { + goto _readField_if_exists; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t DropEdgeIndexReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("DropEdgeIndexReq"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("index_name", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->index_name); + xfer += prot_->serializedFieldSize("if_exists", apache::thrift::protocol::T_BOOL, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::serializedSize(*prot_, this->if_exists); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t DropEdgeIndexReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("DropEdgeIndexReq"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("index_name", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->index_name); + xfer += prot_->serializedFieldSize("if_exists", apache::thrift::protocol::T_BOOL, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::serializedSize(*prot_, this->if_exists); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t DropEdgeIndexReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("DropEdgeIndexReq"); + xfer += prot_->writeFieldBegin("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::write(*prot_, this->space_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("index_name", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->index_name); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("if_exists", apache::thrift::protocol::T_BOOL, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::write(*prot_, this->if_exists); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void DropEdgeIndexReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t DropEdgeIndexReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t DropEdgeIndexReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t DropEdgeIndexReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void DropEdgeIndexReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t DropEdgeIndexReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t DropEdgeIndexReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t DropEdgeIndexReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void GetEdgeIndexReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_space_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::readWithContext(*iprot, this->space_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.space_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_index_name: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->index_name, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.index_name = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_space_id; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_index_name; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t GetEdgeIndexReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("GetEdgeIndexReq"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("index_name", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->index_name); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t GetEdgeIndexReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("GetEdgeIndexReq"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("index_name", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->index_name); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t GetEdgeIndexReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("GetEdgeIndexReq"); + xfer += prot_->writeFieldBegin("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::write(*prot_, this->space_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("index_name", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->index_name); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void GetEdgeIndexReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t GetEdgeIndexReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t GetEdgeIndexReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t GetEdgeIndexReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void GetEdgeIndexReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t GetEdgeIndexReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t GetEdgeIndexReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t GetEdgeIndexReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void GetEdgeIndexResp::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_code: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::readWithContext(*iprot, this->code, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.code = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_leader: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::readWithContext(*iprot, this->leader, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.leader = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_item: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::IndexItem>::readWithContext(*iprot, this->item, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.item = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_code; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_leader; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_item; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t GetEdgeIndexResp::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("GetEdgeIndexResp"); + xfer += prot_->serializedFieldSize("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::serializedSize(*prot_, this->code); + xfer += prot_->serializedFieldSize("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->leader); + xfer += prot_->serializedFieldSize("item", apache::thrift::protocol::T_STRUCT, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::IndexItem>::serializedSize(*prot_, this->item); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t GetEdgeIndexResp::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("GetEdgeIndexResp"); + xfer += prot_->serializedFieldSize("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::serializedSize(*prot_, this->code); + xfer += prot_->serializedFieldSize("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->leader); + xfer += prot_->serializedFieldSize("item", apache::thrift::protocol::T_STRUCT, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::IndexItem>::serializedSize(*prot_, this->item); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t GetEdgeIndexResp::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("GetEdgeIndexResp"); + xfer += prot_->writeFieldBegin("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::write(*prot_, this->code); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::write(*prot_, this->leader); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("item", apache::thrift::protocol::T_STRUCT, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::IndexItem>::write(*prot_, this->item); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void GetEdgeIndexResp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t GetEdgeIndexResp::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t GetEdgeIndexResp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t GetEdgeIndexResp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void GetEdgeIndexResp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t GetEdgeIndexResp::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t GetEdgeIndexResp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t GetEdgeIndexResp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void ListEdgeIndexesReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_space_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::readWithContext(*iprot, this->space_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.space_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_space_id; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t ListEdgeIndexesReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ListEdgeIndexesReq"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ListEdgeIndexesReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ListEdgeIndexesReq"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ListEdgeIndexesReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("ListEdgeIndexesReq"); + xfer += prot_->writeFieldBegin("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::write(*prot_, this->space_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void ListEdgeIndexesReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t ListEdgeIndexesReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t ListEdgeIndexesReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t ListEdgeIndexesReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void ListEdgeIndexesReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t ListEdgeIndexesReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t ListEdgeIndexesReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t ListEdgeIndexesReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void ListEdgeIndexesResp::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_code: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::readWithContext(*iprot, this->code, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.code = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_leader: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::readWithContext(*iprot, this->leader, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.leader = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_items: + { + _readState.beforeSubobject(iprot); + this->items = ::std::vector< ::nebula::meta::cpp2::IndexItem>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::IndexItem>>::readWithContext(*iprot, this->items, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.items = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_code; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_leader; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_items; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t ListEdgeIndexesResp::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ListEdgeIndexesResp"); + xfer += prot_->serializedFieldSize("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::serializedSize(*prot_, this->code); + xfer += prot_->serializedFieldSize("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->leader); + xfer += prot_->serializedFieldSize("items", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::IndexItem>>::serializedSize(*prot_, this->items); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ListEdgeIndexesResp::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ListEdgeIndexesResp"); + xfer += prot_->serializedFieldSize("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::serializedSize(*prot_, this->code); + xfer += prot_->serializedFieldSize("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->leader); + xfer += prot_->serializedFieldSize("items", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::IndexItem>>::serializedSize(*prot_, this->items); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ListEdgeIndexesResp::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("ListEdgeIndexesResp"); + xfer += prot_->writeFieldBegin("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::write(*prot_, this->code); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::write(*prot_, this->leader); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("items", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::IndexItem>>::write(*prot_, this->items); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void ListEdgeIndexesResp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t ListEdgeIndexesResp::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t ListEdgeIndexesResp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t ListEdgeIndexesResp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void ListEdgeIndexesResp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t ListEdgeIndexesResp::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t ListEdgeIndexesResp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t ListEdgeIndexesResp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void RebuildIndexReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_space_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::readWithContext(*iprot, this->space_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.space_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_index_name: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->index_name, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.index_name = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_space_id; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_index_name; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t RebuildIndexReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("RebuildIndexReq"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("index_name", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->index_name); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t RebuildIndexReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("RebuildIndexReq"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("index_name", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->index_name); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t RebuildIndexReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("RebuildIndexReq"); + xfer += prot_->writeFieldBegin("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::write(*prot_, this->space_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("index_name", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->index_name); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void RebuildIndexReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t RebuildIndexReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t RebuildIndexReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t RebuildIndexReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void RebuildIndexReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t RebuildIndexReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t RebuildIndexReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t RebuildIndexReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void CreateUserReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_account: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->account, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.account = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_encoded_pwd: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->encoded_pwd, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.encoded_pwd = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_BOOL))) { + goto _loop; + } +_readField_if_not_exists: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::readWithContext(*iprot, this->if_not_exists, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.if_not_exists = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_account; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_encoded_pwd; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_BOOL))) { + goto _readField_if_not_exists; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t CreateUserReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("CreateUserReq"); + xfer += prot_->serializedFieldSize("account", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->account); + xfer += prot_->serializedFieldSize("encoded_pwd", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->encoded_pwd); + xfer += prot_->serializedFieldSize("if_not_exists", apache::thrift::protocol::T_BOOL, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::serializedSize(*prot_, this->if_not_exists); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t CreateUserReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("CreateUserReq"); + xfer += prot_->serializedFieldSize("account", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->account); + xfer += prot_->serializedFieldSize("encoded_pwd", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->encoded_pwd); + xfer += prot_->serializedFieldSize("if_not_exists", apache::thrift::protocol::T_BOOL, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::serializedSize(*prot_, this->if_not_exists); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t CreateUserReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("CreateUserReq"); + xfer += prot_->writeFieldBegin("account", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->account); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("encoded_pwd", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->encoded_pwd); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("if_not_exists", apache::thrift::protocol::T_BOOL, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::write(*prot_, this->if_not_exists); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void CreateUserReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t CreateUserReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t CreateUserReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t CreateUserReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void CreateUserReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t CreateUserReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t CreateUserReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t CreateUserReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void DropUserReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_account: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->account, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.account = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_BOOL))) { + goto _loop; + } +_readField_if_exists: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::readWithContext(*iprot, this->if_exists, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.if_exists = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_account; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_BOOL))) { + goto _readField_if_exists; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t DropUserReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("DropUserReq"); + xfer += prot_->serializedFieldSize("account", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->account); + xfer += prot_->serializedFieldSize("if_exists", apache::thrift::protocol::T_BOOL, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::serializedSize(*prot_, this->if_exists); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t DropUserReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("DropUserReq"); + xfer += prot_->serializedFieldSize("account", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->account); + xfer += prot_->serializedFieldSize("if_exists", apache::thrift::protocol::T_BOOL, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::serializedSize(*prot_, this->if_exists); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t DropUserReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("DropUserReq"); + xfer += prot_->writeFieldBegin("account", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->account); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("if_exists", apache::thrift::protocol::T_BOOL, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::write(*prot_, this->if_exists); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void DropUserReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t DropUserReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t DropUserReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t DropUserReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void DropUserReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t DropUserReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t DropUserReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t DropUserReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void AlterUserReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_account: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->account, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.account = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_encoded_pwd: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->encoded_pwd, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.encoded_pwd = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_account; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_encoded_pwd; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t AlterUserReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("AlterUserReq"); + xfer += prot_->serializedFieldSize("account", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->account); + xfer += prot_->serializedFieldSize("encoded_pwd", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->encoded_pwd); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t AlterUserReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("AlterUserReq"); + xfer += prot_->serializedFieldSize("account", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->account); + xfer += prot_->serializedFieldSize("encoded_pwd", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->encoded_pwd); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t AlterUserReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("AlterUserReq"); + xfer += prot_->writeFieldBegin("account", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->account); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("encoded_pwd", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->encoded_pwd); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void AlterUserReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t AlterUserReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t AlterUserReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t AlterUserReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void AlterUserReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t AlterUserReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t AlterUserReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t AlterUserReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void GrantRoleReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_role_item: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::RoleItem>::readWithContext(*iprot, this->role_item, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.role_item = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_role_item; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t GrantRoleReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("GrantRoleReq"); + xfer += prot_->serializedFieldSize("role_item", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::RoleItem>::serializedSize(*prot_, this->role_item); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t GrantRoleReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("GrantRoleReq"); + xfer += prot_->serializedFieldSize("role_item", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::RoleItem>::serializedSize(*prot_, this->role_item); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t GrantRoleReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("GrantRoleReq"); + xfer += prot_->writeFieldBegin("role_item", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::RoleItem>::write(*prot_, this->role_item); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void GrantRoleReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t GrantRoleReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t GrantRoleReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t GrantRoleReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void GrantRoleReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t GrantRoleReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t GrantRoleReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t GrantRoleReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void RevokeRoleReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_role_item: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::RoleItem>::readWithContext(*iprot, this->role_item, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.role_item = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_role_item; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t RevokeRoleReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("RevokeRoleReq"); + xfer += prot_->serializedFieldSize("role_item", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::RoleItem>::serializedSize(*prot_, this->role_item); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t RevokeRoleReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("RevokeRoleReq"); + xfer += prot_->serializedFieldSize("role_item", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::RoleItem>::serializedSize(*prot_, this->role_item); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t RevokeRoleReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("RevokeRoleReq"); + xfer += prot_->writeFieldBegin("role_item", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::RoleItem>::write(*prot_, this->role_item); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void RevokeRoleReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t RevokeRoleReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t RevokeRoleReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t RevokeRoleReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void RevokeRoleReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t RevokeRoleReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t RevokeRoleReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t RevokeRoleReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void ListUsersReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + default: + { + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t ListUsersReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ListUsersReq"); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ListUsersReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ListUsersReq"); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ListUsersReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("ListUsersReq"); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void ListUsersReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t ListUsersReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t ListUsersReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t ListUsersReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void ListUsersReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t ListUsersReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t ListUsersReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t ListUsersReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void ListUsersResp::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_code: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::readWithContext(*iprot, this->code, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.code = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_leader: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::readWithContext(*iprot, this->leader, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.leader = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_MAP))) { + goto _loop; + } +_readField_users: + { + _readState.beforeSubobject(iprot); + this->users = std::unordered_map<::std::string, ::std::string>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::binary, ::apache::thrift::type_class::binary>, std::unordered_map<::std::string, ::std::string>>::readWithContext(*iprot, this->users, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.users = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_code; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_leader; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_MAP))) { + goto _readField_users; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t ListUsersResp::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ListUsersResp"); + xfer += prot_->serializedFieldSize("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::serializedSize(*prot_, this->code); + xfer += prot_->serializedFieldSize("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->leader); + xfer += prot_->serializedFieldSize("users", apache::thrift::protocol::T_MAP, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::binary, ::apache::thrift::type_class::binary>, std::unordered_map<::std::string, ::std::string>>::serializedSize(*prot_, this->users); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ListUsersResp::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ListUsersResp"); + xfer += prot_->serializedFieldSize("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::serializedSize(*prot_, this->code); + xfer += prot_->serializedFieldSize("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->leader); + xfer += prot_->serializedFieldSize("users", apache::thrift::protocol::T_MAP, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::binary, ::apache::thrift::type_class::binary>, std::unordered_map<::std::string, ::std::string>>::serializedSize(*prot_, this->users); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ListUsersResp::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("ListUsersResp"); + xfer += prot_->writeFieldBegin("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::write(*prot_, this->code); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::write(*prot_, this->leader); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("users", apache::thrift::protocol::T_MAP, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::binary, ::apache::thrift::type_class::binary>, std::unordered_map<::std::string, ::std::string>>::write(*prot_, this->users); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void ListUsersResp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t ListUsersResp::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t ListUsersResp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t ListUsersResp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void ListUsersResp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t ListUsersResp::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t ListUsersResp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t ListUsersResp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void ListRolesReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_space_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::readWithContext(*iprot, this->space_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.space_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_space_id; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t ListRolesReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ListRolesReq"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ListRolesReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ListRolesReq"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ListRolesReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("ListRolesReq"); + xfer += prot_->writeFieldBegin("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::write(*prot_, this->space_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void ListRolesReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t ListRolesReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t ListRolesReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t ListRolesReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void ListRolesReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t ListRolesReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t ListRolesReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t ListRolesReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void ListRolesResp::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_code: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::readWithContext(*iprot, this->code, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.code = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_leader: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::readWithContext(*iprot, this->leader, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.leader = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_roles: + { + _readState.beforeSubobject(iprot); + this->roles = ::std::vector< ::nebula::meta::cpp2::RoleItem>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::RoleItem>>::readWithContext(*iprot, this->roles, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.roles = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_code; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_leader; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_roles; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t ListRolesResp::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ListRolesResp"); + xfer += prot_->serializedFieldSize("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::serializedSize(*prot_, this->code); + xfer += prot_->serializedFieldSize("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->leader); + xfer += prot_->serializedFieldSize("roles", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::RoleItem>>::serializedSize(*prot_, this->roles); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ListRolesResp::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ListRolesResp"); + xfer += prot_->serializedFieldSize("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::serializedSize(*prot_, this->code); + xfer += prot_->serializedFieldSize("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->leader); + xfer += prot_->serializedFieldSize("roles", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::RoleItem>>::serializedSize(*prot_, this->roles); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ListRolesResp::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("ListRolesResp"); + xfer += prot_->writeFieldBegin("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::write(*prot_, this->code); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::write(*prot_, this->leader); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("roles", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::RoleItem>>::write(*prot_, this->roles); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void ListRolesResp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t ListRolesResp::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t ListRolesResp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t ListRolesResp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void ListRolesResp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t ListRolesResp::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t ListRolesResp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t ListRolesResp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void GetUserRolesReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_account: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->account, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.account = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_account; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t GetUserRolesReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("GetUserRolesReq"); + xfer += prot_->serializedFieldSize("account", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->account); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t GetUserRolesReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("GetUserRolesReq"); + xfer += prot_->serializedFieldSize("account", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->account); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t GetUserRolesReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("GetUserRolesReq"); + xfer += prot_->writeFieldBegin("account", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->account); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void GetUserRolesReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t GetUserRolesReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t GetUserRolesReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t GetUserRolesReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void GetUserRolesReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t GetUserRolesReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t GetUserRolesReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t GetUserRolesReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void ChangePasswordReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_account: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->account, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.account = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_new_encoded_pwd: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->new_encoded_pwd, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.new_encoded_pwd = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_old_encoded_pwd: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->old_encoded_pwd, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.old_encoded_pwd = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_account; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_new_encoded_pwd; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_old_encoded_pwd; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t ChangePasswordReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ChangePasswordReq"); + xfer += prot_->serializedFieldSize("account", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->account); + xfer += prot_->serializedFieldSize("new_encoded_pwd", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->new_encoded_pwd); + xfer += prot_->serializedFieldSize("old_encoded_pwd", apache::thrift::protocol::T_STRING, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->old_encoded_pwd); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ChangePasswordReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ChangePasswordReq"); + xfer += prot_->serializedFieldSize("account", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->account); + xfer += prot_->serializedFieldSize("new_encoded_pwd", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->new_encoded_pwd); + xfer += prot_->serializedFieldSize("old_encoded_pwd", apache::thrift::protocol::T_STRING, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->old_encoded_pwd); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ChangePasswordReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("ChangePasswordReq"); + xfer += prot_->writeFieldBegin("account", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->account); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("new_encoded_pwd", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->new_encoded_pwd); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("old_encoded_pwd", apache::thrift::protocol::T_STRING, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->old_encoded_pwd); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void ChangePasswordReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t ChangePasswordReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t ChangePasswordReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t ChangePasswordReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void ChangePasswordReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t ChangePasswordReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t ChangePasswordReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t ChangePasswordReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void BalanceReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_space_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::readWithContext(*iprot, this->space_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.space_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_I64))) { + goto _loop; + } +_readField_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::readWithContext(*iprot, this->id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_host_del: + { + _readState.beforeSubobject(iprot); + this->host_del = ::std::vector(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector>::readWithContext(*iprot, this->host_del, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.host_del = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 4, + apache::thrift::protocol::T_BOOL))) { + goto _loop; + } +_readField_stop: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::readWithContext(*iprot, this->stop, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.stop = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 4, + 5, + apache::thrift::protocol::T_BOOL))) { + goto _loop; + } +_readField_reset: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::readWithContext(*iprot, this->reset, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.reset = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 5, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_space_id; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I64))) { + goto _readField_id; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_host_del; + } else { + goto _skip; + } + } + case 4: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_BOOL))) { + goto _readField_stop; + } else { + goto _skip; + } + } + case 5: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_BOOL))) { + goto _readField_reset; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t BalanceReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("BalanceReq"); + if (this->space_id_ref().has_value()) { + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + } + if (this->id_ref().has_value()) { + xfer += prot_->serializedFieldSize("id", apache::thrift::protocol::T_I64, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::serializedSize(*prot_, this->id); + } + if (this->host_del_ref().has_value()) { + xfer += prot_->serializedFieldSize("host_del", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector>::serializedSize(*prot_, this->host_del); + } + if (this->stop_ref().has_value()) { + xfer += prot_->serializedFieldSize("stop", apache::thrift::protocol::T_BOOL, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::serializedSize(*prot_, this->stop); + } + if (this->reset_ref().has_value()) { + xfer += prot_->serializedFieldSize("reset", apache::thrift::protocol::T_BOOL, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::serializedSize(*prot_, this->reset); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t BalanceReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("BalanceReq"); + if (this->space_id_ref().has_value()) { + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + } + if (this->id_ref().has_value()) { + xfer += prot_->serializedFieldSize("id", apache::thrift::protocol::T_I64, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::serializedSize(*prot_, this->id); + } + if (this->host_del_ref().has_value()) { + xfer += prot_->serializedFieldSize("host_del", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector>::serializedSize(*prot_, this->host_del); + } + if (this->stop_ref().has_value()) { + xfer += prot_->serializedFieldSize("stop", apache::thrift::protocol::T_BOOL, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::serializedSize(*prot_, this->stop); + } + if (this->reset_ref().has_value()) { + xfer += prot_->serializedFieldSize("reset", apache::thrift::protocol::T_BOOL, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::serializedSize(*prot_, this->reset); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t BalanceReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("BalanceReq"); + if (this->space_id_ref().has_value()) { + xfer += prot_->writeFieldBegin("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::write(*prot_, this->space_id); + xfer += prot_->writeFieldEnd(); + } + if (this->id_ref().has_value()) { + xfer += prot_->writeFieldBegin("id", apache::thrift::protocol::T_I64, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::write(*prot_, this->id); + xfer += prot_->writeFieldEnd(); + } + if (this->host_del_ref().has_value()) { + xfer += prot_->writeFieldBegin("host_del", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector>::write(*prot_, this->host_del); + xfer += prot_->writeFieldEnd(); + } + if (this->stop_ref().has_value()) { + xfer += prot_->writeFieldBegin("stop", apache::thrift::protocol::T_BOOL, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::write(*prot_, this->stop); + xfer += prot_->writeFieldEnd(); + } + if (this->reset_ref().has_value()) { + xfer += prot_->writeFieldBegin("reset", apache::thrift::protocol::T_BOOL, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::write(*prot_, this->reset); + xfer += prot_->writeFieldEnd(); + } + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void BalanceReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t BalanceReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t BalanceReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t BalanceReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void BalanceReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t BalanceReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t BalanceReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t BalanceReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void BalanceTask::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_result: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::TaskResult>::readWithContext(*iprot, this->result, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.result = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_id; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_result; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t BalanceTask::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("BalanceTask"); + xfer += prot_->serializedFieldSize("id", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->id); + xfer += prot_->serializedFieldSize("result", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::TaskResult>::serializedSize(*prot_, this->result); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t BalanceTask::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("BalanceTask"); + xfer += prot_->serializedFieldSize("id", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->id); + xfer += prot_->serializedFieldSize("result", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::TaskResult>::serializedSize(*prot_, this->result); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t BalanceTask::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("BalanceTask"); + xfer += prot_->writeFieldBegin("id", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("result", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::TaskResult>::write(*prot_, this->result); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void BalanceTask::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t BalanceTask::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t BalanceTask::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t BalanceTask::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void BalanceTask::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t BalanceTask::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t BalanceTask::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t BalanceTask::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void BalanceResp::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_code: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::readWithContext(*iprot, this->code, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.code = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_I64))) { + goto _loop; + } +_readField_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::readWithContext(*iprot, this->id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_leader: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::readWithContext(*iprot, this->leader, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.leader = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 4, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_tasks: + { + _readState.beforeSubobject(iprot); + this->tasks = ::std::vector< ::nebula::meta::cpp2::BalanceTask>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::BalanceTask>>::readWithContext(*iprot, this->tasks, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.tasks = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 4, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_code; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I64))) { + goto _readField_id; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_leader; + } else { + goto _skip; + } + } + case 4: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_tasks; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t BalanceResp::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("BalanceResp"); + xfer += prot_->serializedFieldSize("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::serializedSize(*prot_, this->code); + xfer += prot_->serializedFieldSize("id", apache::thrift::protocol::T_I64, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::serializedSize(*prot_, this->id); + xfer += prot_->serializedFieldSize("leader", apache::thrift::protocol::T_STRUCT, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->leader); + xfer += prot_->serializedFieldSize("tasks", apache::thrift::protocol::T_LIST, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::BalanceTask>>::serializedSize(*prot_, this->tasks); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t BalanceResp::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("BalanceResp"); + xfer += prot_->serializedFieldSize("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::serializedSize(*prot_, this->code); + xfer += prot_->serializedFieldSize("id", apache::thrift::protocol::T_I64, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::serializedSize(*prot_, this->id); + xfer += prot_->serializedFieldSize("leader", apache::thrift::protocol::T_STRUCT, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->leader); + xfer += prot_->serializedFieldSize("tasks", apache::thrift::protocol::T_LIST, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::BalanceTask>>::serializedSize(*prot_, this->tasks); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t BalanceResp::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("BalanceResp"); + xfer += prot_->writeFieldBegin("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::write(*prot_, this->code); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("id", apache::thrift::protocol::T_I64, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::write(*prot_, this->id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("leader", apache::thrift::protocol::T_STRUCT, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::write(*prot_, this->leader); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("tasks", apache::thrift::protocol::T_LIST, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::BalanceTask>>::write(*prot_, this->tasks); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void BalanceResp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t BalanceResp::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t BalanceResp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t BalanceResp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void BalanceResp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t BalanceResp::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t BalanceResp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t BalanceResp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void LeaderBalanceReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + default: + { + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t LeaderBalanceReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("LeaderBalanceReq"); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t LeaderBalanceReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("LeaderBalanceReq"); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t LeaderBalanceReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("LeaderBalanceReq"); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void LeaderBalanceReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t LeaderBalanceReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t LeaderBalanceReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t LeaderBalanceReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void LeaderBalanceReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t LeaderBalanceReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t LeaderBalanceReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t LeaderBalanceReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void ConfigItem::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_module: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::ConfigModule>::readWithContext(*iprot, this->module, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.module = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_name: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->name, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.name = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_mode: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::ConfigMode>::readWithContext(*iprot, this->mode, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.mode = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 4, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_value: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::variant, nebula::Value>::readWithContext(*iprot, this->value, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.value = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 4, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_module; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_name; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_mode; + } else { + goto _skip; + } + } + case 4: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_value; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t ConfigItem::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ConfigItem"); + xfer += prot_->serializedFieldSize("module", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::ConfigModule>::serializedSize(*prot_, this->module); + xfer += prot_->serializedFieldSize("name", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->name); + xfer += prot_->serializedFieldSize("mode", apache::thrift::protocol::T_I32, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::ConfigMode>::serializedSize(*prot_, this->mode); + xfer += prot_->serializedFieldSize("value", apache::thrift::protocol::T_STRUCT, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::variant, nebula::Value>::serializedSize(*prot_, this->value); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ConfigItem::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ConfigItem"); + xfer += prot_->serializedFieldSize("module", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::ConfigModule>::serializedSize(*prot_, this->module); + xfer += prot_->serializedFieldSize("name", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->name); + xfer += prot_->serializedFieldSize("mode", apache::thrift::protocol::T_I32, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::ConfigMode>::serializedSize(*prot_, this->mode); + xfer += prot_->serializedFieldSize("value", apache::thrift::protocol::T_STRUCT, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::variant, nebula::Value>::serializedSize(*prot_, this->value); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ConfigItem::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("ConfigItem"); + xfer += prot_->writeFieldBegin("module", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::ConfigModule>::write(*prot_, this->module); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("name", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->name); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("mode", apache::thrift::protocol::T_I32, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::ConfigMode>::write(*prot_, this->mode); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("value", apache::thrift::protocol::T_STRUCT, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::variant, nebula::Value>::write(*prot_, this->value); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void ConfigItem::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t ConfigItem::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t ConfigItem::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t ConfigItem::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void ConfigItem::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t ConfigItem::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t ConfigItem::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t ConfigItem::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void RegConfigReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_items: + { + _readState.beforeSubobject(iprot); + this->items = ::std::vector< ::nebula::meta::cpp2::ConfigItem>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::ConfigItem>>::readWithContext(*iprot, this->items, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.items = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_items; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t RegConfigReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("RegConfigReq"); + xfer += prot_->serializedFieldSize("items", apache::thrift::protocol::T_LIST, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::ConfigItem>>::serializedSize(*prot_, this->items); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t RegConfigReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("RegConfigReq"); + xfer += prot_->serializedFieldSize("items", apache::thrift::protocol::T_LIST, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::ConfigItem>>::serializedSize(*prot_, this->items); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t RegConfigReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("RegConfigReq"); + xfer += prot_->writeFieldBegin("items", apache::thrift::protocol::T_LIST, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::ConfigItem>>::write(*prot_, this->items); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void RegConfigReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t RegConfigReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t RegConfigReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t RegConfigReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void RegConfigReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t RegConfigReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t RegConfigReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t RegConfigReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void GetConfigReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_item: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::ConfigItem>::readWithContext(*iprot, this->item, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.item = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_item; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t GetConfigReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("GetConfigReq"); + xfer += prot_->serializedFieldSize("item", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::ConfigItem>::serializedSize(*prot_, this->item); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t GetConfigReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("GetConfigReq"); + xfer += prot_->serializedFieldSize("item", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::ConfigItem>::serializedSize(*prot_, this->item); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t GetConfigReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("GetConfigReq"); + xfer += prot_->writeFieldBegin("item", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::ConfigItem>::write(*prot_, this->item); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void GetConfigReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t GetConfigReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t GetConfigReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t GetConfigReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void GetConfigReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t GetConfigReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t GetConfigReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t GetConfigReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void GetConfigResp::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_code: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::readWithContext(*iprot, this->code, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.code = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_leader: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::readWithContext(*iprot, this->leader, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.leader = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_items: + { + _readState.beforeSubobject(iprot); + this->items = ::std::vector< ::nebula::meta::cpp2::ConfigItem>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::ConfigItem>>::readWithContext(*iprot, this->items, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.items = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_code; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_leader; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_items; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t GetConfigResp::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("GetConfigResp"); + xfer += prot_->serializedFieldSize("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::serializedSize(*prot_, this->code); + xfer += prot_->serializedFieldSize("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->leader); + xfer += prot_->serializedFieldSize("items", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::ConfigItem>>::serializedSize(*prot_, this->items); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t GetConfigResp::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("GetConfigResp"); + xfer += prot_->serializedFieldSize("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::serializedSize(*prot_, this->code); + xfer += prot_->serializedFieldSize("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->leader); + xfer += prot_->serializedFieldSize("items", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::ConfigItem>>::serializedSize(*prot_, this->items); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t GetConfigResp::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("GetConfigResp"); + xfer += prot_->writeFieldBegin("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::write(*prot_, this->code); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::write(*prot_, this->leader); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("items", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::ConfigItem>>::write(*prot_, this->items); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void GetConfigResp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t GetConfigResp::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t GetConfigResp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t GetConfigResp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void GetConfigResp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t GetConfigResp::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t GetConfigResp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t GetConfigResp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void SetConfigReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_item: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::ConfigItem>::readWithContext(*iprot, this->item, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.item = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_item; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t SetConfigReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("SetConfigReq"); + xfer += prot_->serializedFieldSize("item", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::ConfigItem>::serializedSize(*prot_, this->item); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t SetConfigReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("SetConfigReq"); + xfer += prot_->serializedFieldSize("item", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::ConfigItem>::serializedSize(*prot_, this->item); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t SetConfigReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("SetConfigReq"); + xfer += prot_->writeFieldBegin("item", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::ConfigItem>::write(*prot_, this->item); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void SetConfigReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t SetConfigReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t SetConfigReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t SetConfigReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void SetConfigReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t SetConfigReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t SetConfigReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t SetConfigReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void ListConfigsReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_space: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->space, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.space = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_module: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::ConfigModule>::readWithContext(*iprot, this->module, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.module = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_space; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_module; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t ListConfigsReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ListConfigsReq"); + xfer += prot_->serializedFieldSize("space", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->space); + xfer += prot_->serializedFieldSize("module", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::ConfigModule>::serializedSize(*prot_, this->module); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ListConfigsReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ListConfigsReq"); + xfer += prot_->serializedFieldSize("space", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->space); + xfer += prot_->serializedFieldSize("module", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::ConfigModule>::serializedSize(*prot_, this->module); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ListConfigsReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("ListConfigsReq"); + xfer += prot_->writeFieldBegin("space", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->space); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("module", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::ConfigModule>::write(*prot_, this->module); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void ListConfigsReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t ListConfigsReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t ListConfigsReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t ListConfigsReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void ListConfigsReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t ListConfigsReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t ListConfigsReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t ListConfigsReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void ListConfigsResp::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_code: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::readWithContext(*iprot, this->code, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.code = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_leader: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::readWithContext(*iprot, this->leader, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.leader = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_items: + { + _readState.beforeSubobject(iprot); + this->items = ::std::vector< ::nebula::meta::cpp2::ConfigItem>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::ConfigItem>>::readWithContext(*iprot, this->items, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.items = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_code; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_leader; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_items; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t ListConfigsResp::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ListConfigsResp"); + xfer += prot_->serializedFieldSize("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::serializedSize(*prot_, this->code); + xfer += prot_->serializedFieldSize("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->leader); + xfer += prot_->serializedFieldSize("items", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::ConfigItem>>::serializedSize(*prot_, this->items); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ListConfigsResp::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ListConfigsResp"); + xfer += prot_->serializedFieldSize("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::serializedSize(*prot_, this->code); + xfer += prot_->serializedFieldSize("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->leader); + xfer += prot_->serializedFieldSize("items", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::ConfigItem>>::serializedSize(*prot_, this->items); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ListConfigsResp::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("ListConfigsResp"); + xfer += prot_->writeFieldBegin("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::write(*prot_, this->code); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::write(*prot_, this->leader); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("items", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::ConfigItem>>::write(*prot_, this->items); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void ListConfigsResp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t ListConfigsResp::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t ListConfigsResp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t ListConfigsResp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void ListConfigsResp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t ListConfigsResp::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t ListConfigsResp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t ListConfigsResp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void CreateSnapshotReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + default: + { + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t CreateSnapshotReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("CreateSnapshotReq"); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t CreateSnapshotReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("CreateSnapshotReq"); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t CreateSnapshotReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("CreateSnapshotReq"); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void CreateSnapshotReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t CreateSnapshotReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t CreateSnapshotReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t CreateSnapshotReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void CreateSnapshotReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t CreateSnapshotReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t CreateSnapshotReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t CreateSnapshotReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void DropSnapshotReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_name: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->name, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.name = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_name; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t DropSnapshotReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("DropSnapshotReq"); + xfer += prot_->serializedFieldSize("name", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->name); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t DropSnapshotReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("DropSnapshotReq"); + xfer += prot_->serializedFieldSize("name", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->name); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t DropSnapshotReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("DropSnapshotReq"); + xfer += prot_->writeFieldBegin("name", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->name); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void DropSnapshotReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t DropSnapshotReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t DropSnapshotReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t DropSnapshotReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void DropSnapshotReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t DropSnapshotReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t DropSnapshotReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t DropSnapshotReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void ListSnapshotsReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + default: + { + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t ListSnapshotsReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ListSnapshotsReq"); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ListSnapshotsReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ListSnapshotsReq"); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ListSnapshotsReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("ListSnapshotsReq"); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void ListSnapshotsReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t ListSnapshotsReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t ListSnapshotsReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t ListSnapshotsReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void ListSnapshotsReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t ListSnapshotsReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t ListSnapshotsReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t ListSnapshotsReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void Snapshot::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_name: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->name, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.name = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_status: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::SnapshotStatus>::readWithContext(*iprot, this->status, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.status = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_hosts: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->hosts, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.hosts = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_name; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_status; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_hosts; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t Snapshot::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("Snapshot"); + xfer += prot_->serializedFieldSize("name", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->name); + xfer += prot_->serializedFieldSize("status", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::SnapshotStatus>::serializedSize(*prot_, this->status); + xfer += prot_->serializedFieldSize("hosts", apache::thrift::protocol::T_STRING, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->hosts); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t Snapshot::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("Snapshot"); + xfer += prot_->serializedFieldSize("name", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->name); + xfer += prot_->serializedFieldSize("status", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::SnapshotStatus>::serializedSize(*prot_, this->status); + xfer += prot_->serializedFieldSize("hosts", apache::thrift::protocol::T_STRING, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->hosts); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t Snapshot::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("Snapshot"); + xfer += prot_->writeFieldBegin("name", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->name); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("status", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::SnapshotStatus>::write(*prot_, this->status); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("hosts", apache::thrift::protocol::T_STRING, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->hosts); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void Snapshot::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t Snapshot::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t Snapshot::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t Snapshot::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void Snapshot::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t Snapshot::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t Snapshot::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t Snapshot::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void ListSnapshotsResp::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_code: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::readWithContext(*iprot, this->code, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.code = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_leader: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::readWithContext(*iprot, this->leader, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.leader = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_snapshots: + { + _readState.beforeSubobject(iprot); + this->snapshots = ::std::vector< ::nebula::meta::cpp2::Snapshot>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::Snapshot>>::readWithContext(*iprot, this->snapshots, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.snapshots = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_code; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_leader; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_snapshots; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t ListSnapshotsResp::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ListSnapshotsResp"); + xfer += prot_->serializedFieldSize("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::serializedSize(*prot_, this->code); + xfer += prot_->serializedFieldSize("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->leader); + xfer += prot_->serializedFieldSize("snapshots", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::Snapshot>>::serializedSize(*prot_, this->snapshots); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ListSnapshotsResp::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ListSnapshotsResp"); + xfer += prot_->serializedFieldSize("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::serializedSize(*prot_, this->code); + xfer += prot_->serializedFieldSize("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->leader); + xfer += prot_->serializedFieldSize("snapshots", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::Snapshot>>::serializedSize(*prot_, this->snapshots); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ListSnapshotsResp::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("ListSnapshotsResp"); + xfer += prot_->writeFieldBegin("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::write(*prot_, this->code); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::write(*prot_, this->leader); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("snapshots", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::Snapshot>>::write(*prot_, this->snapshots); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void ListSnapshotsResp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t ListSnapshotsResp::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t ListSnapshotsResp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t ListSnapshotsResp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void ListSnapshotsResp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t ListSnapshotsResp::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t ListSnapshotsResp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t ListSnapshotsResp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void ListIndexStatusReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_space_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::readWithContext(*iprot, this->space_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.space_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_space_id; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t ListIndexStatusReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ListIndexStatusReq"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ListIndexStatusReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ListIndexStatusReq"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ListIndexStatusReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("ListIndexStatusReq"); + xfer += prot_->writeFieldBegin("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::write(*prot_, this->space_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void ListIndexStatusReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t ListIndexStatusReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t ListIndexStatusReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t ListIndexStatusReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void ListIndexStatusReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t ListIndexStatusReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t ListIndexStatusReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t ListIndexStatusReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void IndexStatus::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_name: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->name, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.name = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_status: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->status, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.status = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_name; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_status; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t IndexStatus::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("IndexStatus"); + xfer += prot_->serializedFieldSize("name", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->name); + xfer += prot_->serializedFieldSize("status", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->status); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t IndexStatus::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("IndexStatus"); + xfer += prot_->serializedFieldSize("name", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->name); + xfer += prot_->serializedFieldSize("status", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->status); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t IndexStatus::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("IndexStatus"); + xfer += prot_->writeFieldBegin("name", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->name); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("status", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->status); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void IndexStatus::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t IndexStatus::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t IndexStatus::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t IndexStatus::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void IndexStatus::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t IndexStatus::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t IndexStatus::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t IndexStatus::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void ListIndexStatusResp::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_code: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::readWithContext(*iprot, this->code, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.code = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_leader: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::readWithContext(*iprot, this->leader, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.leader = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_statuses: + { + _readState.beforeSubobject(iprot); + this->statuses = ::std::vector< ::nebula::meta::cpp2::IndexStatus>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::IndexStatus>>::readWithContext(*iprot, this->statuses, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.statuses = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_code; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_leader; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_statuses; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t ListIndexStatusResp::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ListIndexStatusResp"); + xfer += prot_->serializedFieldSize("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::serializedSize(*prot_, this->code); + xfer += prot_->serializedFieldSize("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->leader); + xfer += prot_->serializedFieldSize("statuses", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::IndexStatus>>::serializedSize(*prot_, this->statuses); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ListIndexStatusResp::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ListIndexStatusResp"); + xfer += prot_->serializedFieldSize("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::serializedSize(*prot_, this->code); + xfer += prot_->serializedFieldSize("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->leader); + xfer += prot_->serializedFieldSize("statuses", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::IndexStatus>>::serializedSize(*prot_, this->statuses); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ListIndexStatusResp::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("ListIndexStatusResp"); + xfer += prot_->writeFieldBegin("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::write(*prot_, this->code); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::write(*prot_, this->leader); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("statuses", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::IndexStatus>>::write(*prot_, this->statuses); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void ListIndexStatusResp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t ListIndexStatusResp::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t ListIndexStatusResp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t ListIndexStatusResp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void ListIndexStatusResp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t ListIndexStatusResp::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t ListIndexStatusResp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t ListIndexStatusResp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void AddZoneReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_zone_name: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->zone_name, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.zone_name = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_nodes: + { + _readState.beforeSubobject(iprot); + this->nodes = ::std::vector(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector>::readWithContext(*iprot, this->nodes, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.nodes = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_zone_name; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_nodes; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t AddZoneReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("AddZoneReq"); + xfer += prot_->serializedFieldSize("zone_name", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->zone_name); + xfer += prot_->serializedFieldSize("nodes", apache::thrift::protocol::T_LIST, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector>::serializedSize(*prot_, this->nodes); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t AddZoneReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("AddZoneReq"); + xfer += prot_->serializedFieldSize("zone_name", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->zone_name); + xfer += prot_->serializedFieldSize("nodes", apache::thrift::protocol::T_LIST, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector>::serializedSize(*prot_, this->nodes); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t AddZoneReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("AddZoneReq"); + xfer += prot_->writeFieldBegin("zone_name", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->zone_name); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("nodes", apache::thrift::protocol::T_LIST, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector>::write(*prot_, this->nodes); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void AddZoneReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t AddZoneReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t AddZoneReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t AddZoneReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void AddZoneReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t AddZoneReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t AddZoneReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t AddZoneReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void DropZoneReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_zone_name: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->zone_name, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.zone_name = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_zone_name; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t DropZoneReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("DropZoneReq"); + xfer += prot_->serializedFieldSize("zone_name", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->zone_name); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t DropZoneReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("DropZoneReq"); + xfer += prot_->serializedFieldSize("zone_name", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->zone_name); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t DropZoneReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("DropZoneReq"); + xfer += prot_->writeFieldBegin("zone_name", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->zone_name); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void DropZoneReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t DropZoneReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t DropZoneReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t DropZoneReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void DropZoneReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t DropZoneReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t DropZoneReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t DropZoneReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void AddHostIntoZoneReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_node: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::readWithContext(*iprot, this->node, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.node = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_zone_name: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->zone_name, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.zone_name = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_node; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_zone_name; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t AddHostIntoZoneReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("AddHostIntoZoneReq"); + xfer += prot_->serializedFieldSize("node", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->node); + xfer += prot_->serializedFieldSize("zone_name", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->zone_name); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t AddHostIntoZoneReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("AddHostIntoZoneReq"); + xfer += prot_->serializedFieldSize("node", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->node); + xfer += prot_->serializedFieldSize("zone_name", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->zone_name); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t AddHostIntoZoneReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("AddHostIntoZoneReq"); + xfer += prot_->writeFieldBegin("node", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::write(*prot_, this->node); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("zone_name", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->zone_name); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void AddHostIntoZoneReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t AddHostIntoZoneReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t AddHostIntoZoneReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t AddHostIntoZoneReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void AddHostIntoZoneReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t AddHostIntoZoneReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t AddHostIntoZoneReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t AddHostIntoZoneReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void DropHostFromZoneReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_node: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::readWithContext(*iprot, this->node, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.node = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_zone_name: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->zone_name, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.zone_name = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_node; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_zone_name; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t DropHostFromZoneReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("DropHostFromZoneReq"); + xfer += prot_->serializedFieldSize("node", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->node); + xfer += prot_->serializedFieldSize("zone_name", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->zone_name); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t DropHostFromZoneReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("DropHostFromZoneReq"); + xfer += prot_->serializedFieldSize("node", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->node); + xfer += prot_->serializedFieldSize("zone_name", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->zone_name); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t DropHostFromZoneReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("DropHostFromZoneReq"); + xfer += prot_->writeFieldBegin("node", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::write(*prot_, this->node); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("zone_name", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->zone_name); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void DropHostFromZoneReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t DropHostFromZoneReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t DropHostFromZoneReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t DropHostFromZoneReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void DropHostFromZoneReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t DropHostFromZoneReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t DropHostFromZoneReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t DropHostFromZoneReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void GetZoneReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_zone_name: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->zone_name, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.zone_name = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_zone_name; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t GetZoneReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("GetZoneReq"); + xfer += prot_->serializedFieldSize("zone_name", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->zone_name); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t GetZoneReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("GetZoneReq"); + xfer += prot_->serializedFieldSize("zone_name", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->zone_name); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t GetZoneReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("GetZoneReq"); + xfer += prot_->writeFieldBegin("zone_name", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->zone_name); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void GetZoneReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t GetZoneReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t GetZoneReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t GetZoneReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void GetZoneReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t GetZoneReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t GetZoneReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t GetZoneReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void GetZoneResp::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_code: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::readWithContext(*iprot, this->code, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.code = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_leader: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::readWithContext(*iprot, this->leader, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.leader = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_hosts: + { + _readState.beforeSubobject(iprot); + this->hosts = ::std::vector(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector>::readWithContext(*iprot, this->hosts, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.hosts = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_code; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_leader; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_hosts; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t GetZoneResp::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("GetZoneResp"); + xfer += prot_->serializedFieldSize("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::serializedSize(*prot_, this->code); + xfer += prot_->serializedFieldSize("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->leader); + xfer += prot_->serializedFieldSize("hosts", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector>::serializedSize(*prot_, this->hosts); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t GetZoneResp::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("GetZoneResp"); + xfer += prot_->serializedFieldSize("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::serializedSize(*prot_, this->code); + xfer += prot_->serializedFieldSize("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->leader); + xfer += prot_->serializedFieldSize("hosts", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector>::serializedSize(*prot_, this->hosts); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t GetZoneResp::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("GetZoneResp"); + xfer += prot_->writeFieldBegin("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::write(*prot_, this->code); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::write(*prot_, this->leader); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("hosts", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector>::write(*prot_, this->hosts); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void GetZoneResp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t GetZoneResp::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t GetZoneResp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t GetZoneResp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void GetZoneResp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t GetZoneResp::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t GetZoneResp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t GetZoneResp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void ListZonesReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + default: + { + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t ListZonesReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ListZonesReq"); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ListZonesReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ListZonesReq"); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ListZonesReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("ListZonesReq"); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void ListZonesReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t ListZonesReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t ListZonesReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t ListZonesReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void ListZonesReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t ListZonesReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t ListZonesReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t ListZonesReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void Zone::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_zone_name: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->zone_name, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.zone_name = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_nodes: + { + _readState.beforeSubobject(iprot); + this->nodes = ::std::vector(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector>::readWithContext(*iprot, this->nodes, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.nodes = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_zone_name; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_nodes; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t Zone::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("Zone"); + xfer += prot_->serializedFieldSize("zone_name", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->zone_name); + xfer += prot_->serializedFieldSize("nodes", apache::thrift::protocol::T_LIST, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector>::serializedSize(*prot_, this->nodes); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t Zone::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("Zone"); + xfer += prot_->serializedFieldSize("zone_name", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->zone_name); + xfer += prot_->serializedFieldSize("nodes", apache::thrift::protocol::T_LIST, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector>::serializedSize(*prot_, this->nodes); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t Zone::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("Zone"); + xfer += prot_->writeFieldBegin("zone_name", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->zone_name); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("nodes", apache::thrift::protocol::T_LIST, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector>::write(*prot_, this->nodes); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void Zone::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t Zone::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t Zone::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t Zone::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void Zone::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t Zone::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t Zone::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t Zone::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void ListZonesResp::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_code: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::readWithContext(*iprot, this->code, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.code = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_leader: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::readWithContext(*iprot, this->leader, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.leader = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_zones: + { + _readState.beforeSubobject(iprot); + this->zones = ::std::vector< ::nebula::meta::cpp2::Zone>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::Zone>>::readWithContext(*iprot, this->zones, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.zones = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_code; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_leader; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_zones; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t ListZonesResp::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ListZonesResp"); + xfer += prot_->serializedFieldSize("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::serializedSize(*prot_, this->code); + xfer += prot_->serializedFieldSize("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->leader); + xfer += prot_->serializedFieldSize("zones", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::Zone>>::serializedSize(*prot_, this->zones); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ListZonesResp::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ListZonesResp"); + xfer += prot_->serializedFieldSize("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::serializedSize(*prot_, this->code); + xfer += prot_->serializedFieldSize("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->leader); + xfer += prot_->serializedFieldSize("zones", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::Zone>>::serializedSize(*prot_, this->zones); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ListZonesResp::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("ListZonesResp"); + xfer += prot_->writeFieldBegin("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::write(*prot_, this->code); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::write(*prot_, this->leader); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("zones", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::Zone>>::write(*prot_, this->zones); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void ListZonesResp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t ListZonesResp::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t ListZonesResp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t ListZonesResp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void ListZonesResp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t ListZonesResp::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t ListZonesResp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t ListZonesResp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void AddGroupReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_group_name: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->group_name, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.group_name = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_zone_names: + { + _readState.beforeSubobject(iprot); + this->zone_names = ::std::vector<::std::string>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>, ::std::vector<::std::string>>::readWithContext(*iprot, this->zone_names, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.zone_names = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_group_name; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_zone_names; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t AddGroupReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("AddGroupReq"); + xfer += prot_->serializedFieldSize("group_name", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->group_name); + xfer += prot_->serializedFieldSize("zone_names", apache::thrift::protocol::T_LIST, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>, ::std::vector<::std::string>>::serializedSize(*prot_, this->zone_names); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t AddGroupReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("AddGroupReq"); + xfer += prot_->serializedFieldSize("group_name", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->group_name); + xfer += prot_->serializedFieldSize("zone_names", apache::thrift::protocol::T_LIST, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>, ::std::vector<::std::string>>::serializedSize(*prot_, this->zone_names); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t AddGroupReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("AddGroupReq"); + xfer += prot_->writeFieldBegin("group_name", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->group_name); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("zone_names", apache::thrift::protocol::T_LIST, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>, ::std::vector<::std::string>>::write(*prot_, this->zone_names); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void AddGroupReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t AddGroupReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t AddGroupReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t AddGroupReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void AddGroupReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t AddGroupReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t AddGroupReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t AddGroupReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void DropGroupReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_group_name: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->group_name, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.group_name = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_group_name; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t DropGroupReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("DropGroupReq"); + xfer += prot_->serializedFieldSize("group_name", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->group_name); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t DropGroupReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("DropGroupReq"); + xfer += prot_->serializedFieldSize("group_name", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->group_name); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t DropGroupReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("DropGroupReq"); + xfer += prot_->writeFieldBegin("group_name", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->group_name); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void DropGroupReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t DropGroupReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t DropGroupReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t DropGroupReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void DropGroupReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t DropGroupReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t DropGroupReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t DropGroupReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void AddZoneIntoGroupReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_zone_name: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->zone_name, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.zone_name = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_group_name: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->group_name, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.group_name = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_zone_name; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_group_name; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t AddZoneIntoGroupReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("AddZoneIntoGroupReq"); + xfer += prot_->serializedFieldSize("zone_name", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->zone_name); + xfer += prot_->serializedFieldSize("group_name", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->group_name); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t AddZoneIntoGroupReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("AddZoneIntoGroupReq"); + xfer += prot_->serializedFieldSize("zone_name", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->zone_name); + xfer += prot_->serializedFieldSize("group_name", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->group_name); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t AddZoneIntoGroupReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("AddZoneIntoGroupReq"); + xfer += prot_->writeFieldBegin("zone_name", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->zone_name); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("group_name", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->group_name); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void AddZoneIntoGroupReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t AddZoneIntoGroupReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t AddZoneIntoGroupReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t AddZoneIntoGroupReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void AddZoneIntoGroupReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t AddZoneIntoGroupReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t AddZoneIntoGroupReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t AddZoneIntoGroupReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void DropZoneFromGroupReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_zone_name: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->zone_name, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.zone_name = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_group_name: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->group_name, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.group_name = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_zone_name; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_group_name; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t DropZoneFromGroupReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("DropZoneFromGroupReq"); + xfer += prot_->serializedFieldSize("zone_name", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->zone_name); + xfer += prot_->serializedFieldSize("group_name", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->group_name); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t DropZoneFromGroupReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("DropZoneFromGroupReq"); + xfer += prot_->serializedFieldSize("zone_name", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->zone_name); + xfer += prot_->serializedFieldSize("group_name", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->group_name); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t DropZoneFromGroupReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("DropZoneFromGroupReq"); + xfer += prot_->writeFieldBegin("zone_name", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->zone_name); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("group_name", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->group_name); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void DropZoneFromGroupReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t DropZoneFromGroupReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t DropZoneFromGroupReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t DropZoneFromGroupReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void DropZoneFromGroupReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t DropZoneFromGroupReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t DropZoneFromGroupReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t DropZoneFromGroupReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void GetGroupReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_group_name: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->group_name, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.group_name = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_group_name; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t GetGroupReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("GetGroupReq"); + xfer += prot_->serializedFieldSize("group_name", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->group_name); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t GetGroupReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("GetGroupReq"); + xfer += prot_->serializedFieldSize("group_name", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->group_name); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t GetGroupReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("GetGroupReq"); + xfer += prot_->writeFieldBegin("group_name", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->group_name); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void GetGroupReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t GetGroupReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t GetGroupReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t GetGroupReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void GetGroupReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t GetGroupReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t GetGroupReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t GetGroupReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void GetGroupResp::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_code: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::readWithContext(*iprot, this->code, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.code = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_leader: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::readWithContext(*iprot, this->leader, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.leader = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_zone_names: + { + _readState.beforeSubobject(iprot); + this->zone_names = ::std::vector<::std::string>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>, ::std::vector<::std::string>>::readWithContext(*iprot, this->zone_names, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.zone_names = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_code; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_leader; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_zone_names; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t GetGroupResp::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("GetGroupResp"); + xfer += prot_->serializedFieldSize("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::serializedSize(*prot_, this->code); + xfer += prot_->serializedFieldSize("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->leader); + xfer += prot_->serializedFieldSize("zone_names", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>, ::std::vector<::std::string>>::serializedSize(*prot_, this->zone_names); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t GetGroupResp::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("GetGroupResp"); + xfer += prot_->serializedFieldSize("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::serializedSize(*prot_, this->code); + xfer += prot_->serializedFieldSize("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->leader); + xfer += prot_->serializedFieldSize("zone_names", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>, ::std::vector<::std::string>>::serializedSize(*prot_, this->zone_names); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t GetGroupResp::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("GetGroupResp"); + xfer += prot_->writeFieldBegin("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::write(*prot_, this->code); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::write(*prot_, this->leader); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("zone_names", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>, ::std::vector<::std::string>>::write(*prot_, this->zone_names); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void GetGroupResp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t GetGroupResp::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t GetGroupResp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t GetGroupResp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void GetGroupResp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t GetGroupResp::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t GetGroupResp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t GetGroupResp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void ListGroupsReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + default: + { + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t ListGroupsReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ListGroupsReq"); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ListGroupsReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ListGroupsReq"); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ListGroupsReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("ListGroupsReq"); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void ListGroupsReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t ListGroupsReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t ListGroupsReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t ListGroupsReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void ListGroupsReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t ListGroupsReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t ListGroupsReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t ListGroupsReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void Group::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_group_name: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->group_name, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.group_name = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_zone_names: + { + _readState.beforeSubobject(iprot); + this->zone_names = ::std::vector<::std::string>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>, ::std::vector<::std::string>>::readWithContext(*iprot, this->zone_names, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.zone_names = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_group_name; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_zone_names; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t Group::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("Group"); + xfer += prot_->serializedFieldSize("group_name", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->group_name); + xfer += prot_->serializedFieldSize("zone_names", apache::thrift::protocol::T_LIST, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>, ::std::vector<::std::string>>::serializedSize(*prot_, this->zone_names); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t Group::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("Group"); + xfer += prot_->serializedFieldSize("group_name", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->group_name); + xfer += prot_->serializedFieldSize("zone_names", apache::thrift::protocol::T_LIST, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>, ::std::vector<::std::string>>::serializedSize(*prot_, this->zone_names); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t Group::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("Group"); + xfer += prot_->writeFieldBegin("group_name", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->group_name); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("zone_names", apache::thrift::protocol::T_LIST, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>, ::std::vector<::std::string>>::write(*prot_, this->zone_names); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void Group::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t Group::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t Group::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t Group::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void Group::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t Group::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t Group::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t Group::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void ListGroupsResp::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_code: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::readWithContext(*iprot, this->code, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.code = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_leader: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::readWithContext(*iprot, this->leader, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.leader = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_groups: + { + _readState.beforeSubobject(iprot); + this->groups = ::std::vector< ::nebula::meta::cpp2::Group>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::Group>>::readWithContext(*iprot, this->groups, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.groups = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_code; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_leader; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_groups; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t ListGroupsResp::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ListGroupsResp"); + xfer += prot_->serializedFieldSize("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::serializedSize(*prot_, this->code); + xfer += prot_->serializedFieldSize("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->leader); + xfer += prot_->serializedFieldSize("groups", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::Group>>::serializedSize(*prot_, this->groups); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ListGroupsResp::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ListGroupsResp"); + xfer += prot_->serializedFieldSize("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::serializedSize(*prot_, this->code); + xfer += prot_->serializedFieldSize("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->leader); + xfer += prot_->serializedFieldSize("groups", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::Group>>::serializedSize(*prot_, this->groups); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ListGroupsResp::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("ListGroupsResp"); + xfer += prot_->writeFieldBegin("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::write(*prot_, this->code); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::write(*prot_, this->leader); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("groups", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::Group>>::write(*prot_, this->groups); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void ListGroupsResp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t ListGroupsResp::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t ListGroupsResp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t ListGroupsResp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void ListGroupsResp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t ListGroupsResp::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t ListGroupsResp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t ListGroupsResp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void AddListenerReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_space_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::readWithContext(*iprot, this->space_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.space_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_type: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::ListenerType>::readWithContext(*iprot, this->type, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.type = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_hosts: + { + _readState.beforeSubobject(iprot); + this->hosts = ::std::vector(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector>::readWithContext(*iprot, this->hosts, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.hosts = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_space_id; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_type; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_hosts; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t AddListenerReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("AddListenerReq"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("type", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::ListenerType>::serializedSize(*prot_, this->type); + xfer += prot_->serializedFieldSize("hosts", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector>::serializedSize(*prot_, this->hosts); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t AddListenerReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("AddListenerReq"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("type", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::ListenerType>::serializedSize(*prot_, this->type); + xfer += prot_->serializedFieldSize("hosts", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector>::serializedSize(*prot_, this->hosts); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t AddListenerReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("AddListenerReq"); + xfer += prot_->writeFieldBegin("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::write(*prot_, this->space_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("type", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::ListenerType>::write(*prot_, this->type); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("hosts", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector>::write(*prot_, this->hosts); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void AddListenerReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t AddListenerReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t AddListenerReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t AddListenerReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void AddListenerReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t AddListenerReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t AddListenerReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t AddListenerReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void RemoveListenerReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_space_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::readWithContext(*iprot, this->space_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.space_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_type: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::ListenerType>::readWithContext(*iprot, this->type, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.type = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_space_id; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_type; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t RemoveListenerReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("RemoveListenerReq"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("type", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::ListenerType>::serializedSize(*prot_, this->type); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t RemoveListenerReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("RemoveListenerReq"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("type", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::ListenerType>::serializedSize(*prot_, this->type); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t RemoveListenerReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("RemoveListenerReq"); + xfer += prot_->writeFieldBegin("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::write(*prot_, this->space_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("type", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::ListenerType>::write(*prot_, this->type); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void RemoveListenerReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t RemoveListenerReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t RemoveListenerReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t RemoveListenerReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void RemoveListenerReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t RemoveListenerReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t RemoveListenerReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t RemoveListenerReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void ListListenerReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_space_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::readWithContext(*iprot, this->space_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.space_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_space_id; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t ListListenerReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ListListenerReq"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ListListenerReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ListListenerReq"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ListListenerReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("ListListenerReq"); + xfer += prot_->writeFieldBegin("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::write(*prot_, this->space_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void ListListenerReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t ListListenerReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t ListListenerReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t ListListenerReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void ListListenerReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t ListListenerReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t ListListenerReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t ListListenerReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void ListenerInfo::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_type: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::ListenerType>::readWithContext(*iprot, this->type, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.type = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_host: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::readWithContext(*iprot, this->host, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.host = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_part_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::PartitionID>::readWithContext(*iprot, this->part_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.part_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 4, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_status: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::HostStatus>::readWithContext(*iprot, this->status, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.status = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 4, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_type; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_host; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_part_id; + } else { + goto _skip; + } + } + case 4: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_status; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t ListenerInfo::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ListenerInfo"); + xfer += prot_->serializedFieldSize("type", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::ListenerType>::serializedSize(*prot_, this->type); + xfer += prot_->serializedFieldSize("host", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->host); + xfer += prot_->serializedFieldSize("part_id", apache::thrift::protocol::T_I32, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::PartitionID>::serializedSize(*prot_, this->part_id); + xfer += prot_->serializedFieldSize("status", apache::thrift::protocol::T_I32, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::HostStatus>::serializedSize(*prot_, this->status); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ListenerInfo::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ListenerInfo"); + xfer += prot_->serializedFieldSize("type", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::ListenerType>::serializedSize(*prot_, this->type); + xfer += prot_->serializedFieldSize("host", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->host); + xfer += prot_->serializedFieldSize("part_id", apache::thrift::protocol::T_I32, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::PartitionID>::serializedSize(*prot_, this->part_id); + xfer += prot_->serializedFieldSize("status", apache::thrift::protocol::T_I32, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::HostStatus>::serializedSize(*prot_, this->status); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ListenerInfo::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("ListenerInfo"); + xfer += prot_->writeFieldBegin("type", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::ListenerType>::write(*prot_, this->type); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("host", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::write(*prot_, this->host); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("part_id", apache::thrift::protocol::T_I32, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::PartitionID>::write(*prot_, this->part_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("status", apache::thrift::protocol::T_I32, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::HostStatus>::write(*prot_, this->status); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void ListenerInfo::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t ListenerInfo::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t ListenerInfo::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t ListenerInfo::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void ListenerInfo::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t ListenerInfo::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t ListenerInfo::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t ListenerInfo::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void ListListenerResp::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_code: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::readWithContext(*iprot, this->code, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.code = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_leader: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::readWithContext(*iprot, this->leader, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.leader = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_listeners: + { + _readState.beforeSubobject(iprot); + this->listeners = ::std::vector< ::nebula::meta::cpp2::ListenerInfo>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::ListenerInfo>>::readWithContext(*iprot, this->listeners, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.listeners = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_code; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_leader; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_listeners; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t ListListenerResp::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ListListenerResp"); + xfer += prot_->serializedFieldSize("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::serializedSize(*prot_, this->code); + xfer += prot_->serializedFieldSize("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->leader); + xfer += prot_->serializedFieldSize("listeners", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::ListenerInfo>>::serializedSize(*prot_, this->listeners); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ListListenerResp::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ListListenerResp"); + xfer += prot_->serializedFieldSize("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::serializedSize(*prot_, this->code); + xfer += prot_->serializedFieldSize("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->leader); + xfer += prot_->serializedFieldSize("listeners", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::ListenerInfo>>::serializedSize(*prot_, this->listeners); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ListListenerResp::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("ListListenerResp"); + xfer += prot_->writeFieldBegin("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::write(*prot_, this->code); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::write(*prot_, this->leader); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("listeners", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::ListenerInfo>>::write(*prot_, this->listeners); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void ListListenerResp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t ListListenerResp::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t ListListenerResp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t ListListenerResp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void ListListenerResp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t ListListenerResp::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t ListListenerResp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t ListListenerResp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void GetStatsReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_space_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::readWithContext(*iprot, this->space_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.space_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_space_id; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t GetStatsReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("GetStatsReq"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t GetStatsReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("GetStatsReq"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t GetStatsReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("GetStatsReq"); + xfer += prot_->writeFieldBegin("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::write(*prot_, this->space_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void GetStatsReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t GetStatsReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t GetStatsReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t GetStatsReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void GetStatsReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t GetStatsReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t GetStatsReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t GetStatsReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void GetStatsResp::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_code: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::readWithContext(*iprot, this->code, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.code = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_leader: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::readWithContext(*iprot, this->leader, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.leader = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_stats: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::StatsItem>::readWithContext(*iprot, this->stats, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.stats = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_code; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_leader; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_stats; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t GetStatsResp::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("GetStatsResp"); + xfer += prot_->serializedFieldSize("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::serializedSize(*prot_, this->code); + xfer += prot_->serializedFieldSize("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->leader); + xfer += prot_->serializedFieldSize("stats", apache::thrift::protocol::T_STRUCT, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::StatsItem>::serializedSize(*prot_, this->stats); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t GetStatsResp::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("GetStatsResp"); + xfer += prot_->serializedFieldSize("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::serializedSize(*prot_, this->code); + xfer += prot_->serializedFieldSize("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->leader); + xfer += prot_->serializedFieldSize("stats", apache::thrift::protocol::T_STRUCT, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::StatsItem>::serializedSize(*prot_, this->stats); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t GetStatsResp::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("GetStatsResp"); + xfer += prot_->writeFieldBegin("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::write(*prot_, this->code); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::write(*prot_, this->leader); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("stats", apache::thrift::protocol::T_STRUCT, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::StatsItem>::write(*prot_, this->stats); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void GetStatsResp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t GetStatsResp::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t GetStatsResp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t GetStatsResp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void GetStatsResp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t GetStatsResp::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t GetStatsResp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t GetStatsResp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void BackupInfo::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_host: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::readWithContext(*iprot, this->host, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.host = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_info: + { + _readState.beforeSubobject(iprot); + this->info = ::std::vector< ::nebula::cpp2::CheckpointInfo>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::cpp2::CheckpointInfo>>::readWithContext(*iprot, this->info, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.info = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_host; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_info; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t BackupInfo::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("BackupInfo"); + xfer += prot_->serializedFieldSize("host", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->host); + xfer += prot_->serializedFieldSize("info", apache::thrift::protocol::T_LIST, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::cpp2::CheckpointInfo>>::serializedSize(*prot_, this->info); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t BackupInfo::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("BackupInfo"); + xfer += prot_->serializedFieldSize("host", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->host); + xfer += prot_->serializedFieldSize("info", apache::thrift::protocol::T_LIST, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::cpp2::CheckpointInfo>>::serializedSize(*prot_, this->info); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t BackupInfo::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("BackupInfo"); + xfer += prot_->writeFieldBegin("host", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::write(*prot_, this->host); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("info", apache::thrift::protocol::T_LIST, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::cpp2::CheckpointInfo>>::write(*prot_, this->info); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void BackupInfo::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t BackupInfo::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t BackupInfo::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t BackupInfo::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void BackupInfo::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t BackupInfo::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t BackupInfo::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t BackupInfo::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void SpaceBackupInfo::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_space: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::SpaceDesc>::readWithContext(*iprot, this->space, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.space = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_info: + { + _readState.beforeSubobject(iprot); + this->info = ::std::vector< ::nebula::meta::cpp2::BackupInfo>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::BackupInfo>>::readWithContext(*iprot, this->info, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.info = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_space; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_info; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t SpaceBackupInfo::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("SpaceBackupInfo"); + xfer += prot_->serializedFieldSize("space", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::SpaceDesc>::serializedSize(*prot_, this->space); + xfer += prot_->serializedFieldSize("info", apache::thrift::protocol::T_LIST, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::BackupInfo>>::serializedSize(*prot_, this->info); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t SpaceBackupInfo::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("SpaceBackupInfo"); + xfer += prot_->serializedFieldSize("space", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::SpaceDesc>::serializedSize(*prot_, this->space); + xfer += prot_->serializedFieldSize("info", apache::thrift::protocol::T_LIST, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::BackupInfo>>::serializedSize(*prot_, this->info); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t SpaceBackupInfo::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("SpaceBackupInfo"); + xfer += prot_->writeFieldBegin("space", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::SpaceDesc>::write(*prot_, this->space); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("info", apache::thrift::protocol::T_LIST, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::BackupInfo>>::write(*prot_, this->info); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void SpaceBackupInfo::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t SpaceBackupInfo::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t SpaceBackupInfo::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t SpaceBackupInfo::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void SpaceBackupInfo::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t SpaceBackupInfo::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t SpaceBackupInfo::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t SpaceBackupInfo::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void BackupMeta::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_MAP))) { + goto _loop; + } +_readField_backup_info: + { + _readState.beforeSubobject(iprot); + this->backup_info = std::unordered_map< ::nebula::cpp2::GraphSpaceID, ::nebula::meta::cpp2::SpaceBackupInfo>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::structure>, std::unordered_map< ::nebula::cpp2::GraphSpaceID, ::nebula::meta::cpp2::SpaceBackupInfo>>::readWithContext(*iprot, this->backup_info, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.backup_info = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_meta_files: + { + _readState.beforeSubobject(iprot); + this->meta_files = ::std::vector<::std::string>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>, ::std::vector<::std::string>>::readWithContext(*iprot, this->meta_files, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.meta_files = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_backup_name: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->backup_name, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.backup_name = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 4, + apache::thrift::protocol::T_BOOL))) { + goto _loop; + } +_readField_full: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::readWithContext(*iprot, this->full, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.full = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 4, + 5, + apache::thrift::protocol::T_BOOL))) { + goto _loop; + } +_readField_include_system_space: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::readWithContext(*iprot, this->include_system_space, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.include_system_space = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 5, + 6, + apache::thrift::protocol::T_I64))) { + goto _loop; + } +_readField_create_time: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::readWithContext(*iprot, this->create_time, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.create_time = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 6, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_MAP))) { + goto _readField_backup_info; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_meta_files; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_backup_name; + } else { + goto _skip; + } + } + case 4: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_BOOL))) { + goto _readField_full; + } else { + goto _skip; + } + } + case 5: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_BOOL))) { + goto _readField_include_system_space; + } else { + goto _skip; + } + } + case 6: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I64))) { + goto _readField_create_time; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t BackupMeta::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("BackupMeta"); + xfer += prot_->serializedFieldSize("backup_info", apache::thrift::protocol::T_MAP, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::structure>, std::unordered_map< ::nebula::cpp2::GraphSpaceID, ::nebula::meta::cpp2::SpaceBackupInfo>>::serializedSize(*prot_, this->backup_info); + xfer += prot_->serializedFieldSize("meta_files", apache::thrift::protocol::T_LIST, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>, ::std::vector<::std::string>>::serializedSize(*prot_, this->meta_files); + xfer += prot_->serializedFieldSize("backup_name", apache::thrift::protocol::T_STRING, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->backup_name); + xfer += prot_->serializedFieldSize("full", apache::thrift::protocol::T_BOOL, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::serializedSize(*prot_, this->full); + xfer += prot_->serializedFieldSize("include_system_space", apache::thrift::protocol::T_BOOL, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::serializedSize(*prot_, this->include_system_space); + xfer += prot_->serializedFieldSize("create_time", apache::thrift::protocol::T_I64, 6); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::serializedSize(*prot_, this->create_time); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t BackupMeta::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("BackupMeta"); + xfer += prot_->serializedFieldSize("backup_info", apache::thrift::protocol::T_MAP, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::structure>, std::unordered_map< ::nebula::cpp2::GraphSpaceID, ::nebula::meta::cpp2::SpaceBackupInfo>>::serializedSize(*prot_, this->backup_info); + xfer += prot_->serializedFieldSize("meta_files", apache::thrift::protocol::T_LIST, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>, ::std::vector<::std::string>>::serializedSize(*prot_, this->meta_files); + xfer += prot_->serializedFieldSize("backup_name", apache::thrift::protocol::T_STRING, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->backup_name); + xfer += prot_->serializedFieldSize("full", apache::thrift::protocol::T_BOOL, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::serializedSize(*prot_, this->full); + xfer += prot_->serializedFieldSize("include_system_space", apache::thrift::protocol::T_BOOL, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::serializedSize(*prot_, this->include_system_space); + xfer += prot_->serializedFieldSize("create_time", apache::thrift::protocol::T_I64, 6); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::serializedSize(*prot_, this->create_time); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t BackupMeta::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("BackupMeta"); + xfer += prot_->writeFieldBegin("backup_info", apache::thrift::protocol::T_MAP, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::structure>, std::unordered_map< ::nebula::cpp2::GraphSpaceID, ::nebula::meta::cpp2::SpaceBackupInfo>>::write(*prot_, this->backup_info); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("meta_files", apache::thrift::protocol::T_LIST, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>, ::std::vector<::std::string>>::write(*prot_, this->meta_files); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("backup_name", apache::thrift::protocol::T_STRING, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->backup_name); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("full", apache::thrift::protocol::T_BOOL, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::write(*prot_, this->full); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("include_system_space", apache::thrift::protocol::T_BOOL, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::write(*prot_, this->include_system_space); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("create_time", apache::thrift::protocol::T_I64, 6); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::write(*prot_, this->create_time); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void BackupMeta::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t BackupMeta::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t BackupMeta::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t BackupMeta::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void BackupMeta::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t BackupMeta::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t BackupMeta::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t BackupMeta::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void CreateBackupReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_spaces: + { + _readState.beforeSubobject(iprot); + this->spaces = ::std::vector<::std::string>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>, ::std::vector<::std::string>>::readWithContext(*iprot, this->spaces, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.spaces = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_spaces; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t CreateBackupReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("CreateBackupReq"); + if (this->spaces_ref().has_value()) { + xfer += prot_->serializedFieldSize("spaces", apache::thrift::protocol::T_LIST, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>, ::std::vector<::std::string>>::serializedSize(*prot_, this->spaces); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t CreateBackupReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("CreateBackupReq"); + if (this->spaces_ref().has_value()) { + xfer += prot_->serializedFieldSize("spaces", apache::thrift::protocol::T_LIST, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>, ::std::vector<::std::string>>::serializedSize(*prot_, this->spaces); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t CreateBackupReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("CreateBackupReq"); + if (this->spaces_ref().has_value()) { + xfer += prot_->writeFieldBegin("spaces", apache::thrift::protocol::T_LIST, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>, ::std::vector<::std::string>>::write(*prot_, this->spaces); + xfer += prot_->writeFieldEnd(); + } + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void CreateBackupReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t CreateBackupReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t CreateBackupReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t CreateBackupReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void CreateBackupReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t CreateBackupReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t CreateBackupReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t CreateBackupReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void CreateBackupResp::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_code: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::readWithContext(*iprot, this->code, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.code = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_leader: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::readWithContext(*iprot, this->leader, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.leader = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_meta: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::BackupMeta>::readWithContext(*iprot, this->meta, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.meta = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_code; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_leader; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_meta; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t CreateBackupResp::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("CreateBackupResp"); + xfer += prot_->serializedFieldSize("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::serializedSize(*prot_, this->code); + xfer += prot_->serializedFieldSize("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->leader); + xfer += prot_->serializedFieldSize("meta", apache::thrift::protocol::T_STRUCT, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::BackupMeta>::serializedSize(*prot_, this->meta); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t CreateBackupResp::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("CreateBackupResp"); + xfer += prot_->serializedFieldSize("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::serializedSize(*prot_, this->code); + xfer += prot_->serializedFieldSize("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->leader); + xfer += prot_->serializedFieldSize("meta", apache::thrift::protocol::T_STRUCT, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::BackupMeta>::serializedSize(*prot_, this->meta); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t CreateBackupResp::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("CreateBackupResp"); + xfer += prot_->writeFieldBegin("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::write(*prot_, this->code); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::write(*prot_, this->leader); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("meta", apache::thrift::protocol::T_STRUCT, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::BackupMeta>::write(*prot_, this->meta); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void CreateBackupResp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t CreateBackupResp::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t CreateBackupResp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t CreateBackupResp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void CreateBackupResp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t CreateBackupResp::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t CreateBackupResp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t CreateBackupResp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void HostPair::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_from_host: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::readWithContext(*iprot, this->from_host, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.from_host = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_to_host: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::readWithContext(*iprot, this->to_host, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.to_host = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_from_host; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_to_host; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t HostPair::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("HostPair"); + xfer += prot_->serializedFieldSize("from_host", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->from_host); + xfer += prot_->serializedFieldSize("to_host", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->to_host); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t HostPair::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("HostPair"); + xfer += prot_->serializedFieldSize("from_host", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->from_host); + xfer += prot_->serializedFieldSize("to_host", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->to_host); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t HostPair::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("HostPair"); + xfer += prot_->writeFieldBegin("from_host", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::write(*prot_, this->from_host); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("to_host", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::write(*prot_, this->to_host); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void HostPair::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t HostPair::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t HostPair::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t HostPair::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void HostPair::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t HostPair::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t HostPair::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t HostPair::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void RestoreMetaReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_files: + { + _readState.beforeSubobject(iprot); + this->files = ::std::vector<::std::string>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>, ::std::vector<::std::string>>::readWithContext(*iprot, this->files, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.files = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_hosts: + { + _readState.beforeSubobject(iprot); + this->hosts = ::std::vector< ::nebula::meta::cpp2::HostPair>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::HostPair>>::readWithContext(*iprot, this->hosts, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.hosts = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_files; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_hosts; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t RestoreMetaReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("RestoreMetaReq"); + xfer += prot_->serializedFieldSize("files", apache::thrift::protocol::T_LIST, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>, ::std::vector<::std::string>>::serializedSize(*prot_, this->files); + xfer += prot_->serializedFieldSize("hosts", apache::thrift::protocol::T_LIST, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::HostPair>>::serializedSize(*prot_, this->hosts); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t RestoreMetaReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("RestoreMetaReq"); + xfer += prot_->serializedFieldSize("files", apache::thrift::protocol::T_LIST, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>, ::std::vector<::std::string>>::serializedSize(*prot_, this->files); + xfer += prot_->serializedFieldSize("hosts", apache::thrift::protocol::T_LIST, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::HostPair>>::serializedSize(*prot_, this->hosts); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t RestoreMetaReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("RestoreMetaReq"); + xfer += prot_->writeFieldBegin("files", apache::thrift::protocol::T_LIST, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>, ::std::vector<::std::string>>::write(*prot_, this->files); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("hosts", apache::thrift::protocol::T_LIST, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::HostPair>>::write(*prot_, this->hosts); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void RestoreMetaReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t RestoreMetaReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t RestoreMetaReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t RestoreMetaReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void RestoreMetaReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t RestoreMetaReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t RestoreMetaReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t RestoreMetaReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void FTClient::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_host: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::readWithContext(*iprot, this->host, _readState); + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_user: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->user, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.user = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_pwd: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->pwd, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.pwd = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_host; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_user; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_pwd; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t FTClient::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("FTClient"); + xfer += prot_->serializedFieldSize("host", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->host); + if (this->user_ref().has_value()) { + xfer += prot_->serializedFieldSize("user", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->user); + } + if (this->pwd_ref().has_value()) { + xfer += prot_->serializedFieldSize("pwd", apache::thrift::protocol::T_STRING, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->pwd); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t FTClient::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("FTClient"); + xfer += prot_->serializedFieldSize("host", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->host); + if (this->user_ref().has_value()) { + xfer += prot_->serializedFieldSize("user", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->user); + } + if (this->pwd_ref().has_value()) { + xfer += prot_->serializedFieldSize("pwd", apache::thrift::protocol::T_STRING, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->pwd); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t FTClient::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("FTClient"); + xfer += prot_->writeFieldBegin("host", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::write(*prot_, this->host); + xfer += prot_->writeFieldEnd(); + if (this->user_ref().has_value()) { + xfer += prot_->writeFieldBegin("user", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->user); + xfer += prot_->writeFieldEnd(); + } + if (this->pwd_ref().has_value()) { + xfer += prot_->writeFieldBegin("pwd", apache::thrift::protocol::T_STRING, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->pwd); + xfer += prot_->writeFieldEnd(); + } + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void FTClient::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t FTClient::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t FTClient::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t FTClient::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void FTClient::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t FTClient::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t FTClient::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t FTClient::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void SignInFTServiceReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_type: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::FTServiceType>::readWithContext(*iprot, this->type, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.type = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_clients: + { + _readState.beforeSubobject(iprot); + this->clients = ::std::vector< ::nebula::meta::cpp2::FTClient>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::FTClient>>::readWithContext(*iprot, this->clients, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.clients = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_type; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_clients; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t SignInFTServiceReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("SignInFTServiceReq"); + xfer += prot_->serializedFieldSize("type", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::FTServiceType>::serializedSize(*prot_, this->type); + xfer += prot_->serializedFieldSize("clients", apache::thrift::protocol::T_LIST, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::FTClient>>::serializedSize(*prot_, this->clients); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t SignInFTServiceReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("SignInFTServiceReq"); + xfer += prot_->serializedFieldSize("type", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::FTServiceType>::serializedSize(*prot_, this->type); + xfer += prot_->serializedFieldSize("clients", apache::thrift::protocol::T_LIST, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::FTClient>>::serializedSize(*prot_, this->clients); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t SignInFTServiceReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("SignInFTServiceReq"); + xfer += prot_->writeFieldBegin("type", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::FTServiceType>::write(*prot_, this->type); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("clients", apache::thrift::protocol::T_LIST, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::FTClient>>::write(*prot_, this->clients); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void SignInFTServiceReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t SignInFTServiceReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t SignInFTServiceReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t SignInFTServiceReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void SignInFTServiceReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t SignInFTServiceReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t SignInFTServiceReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t SignInFTServiceReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void SignOutFTServiceReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + default: + { + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t SignOutFTServiceReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("SignOutFTServiceReq"); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t SignOutFTServiceReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("SignOutFTServiceReq"); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t SignOutFTServiceReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("SignOutFTServiceReq"); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void SignOutFTServiceReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t SignOutFTServiceReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t SignOutFTServiceReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t SignOutFTServiceReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void SignOutFTServiceReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t SignOutFTServiceReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t SignOutFTServiceReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t SignOutFTServiceReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void ListFTClientsReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + default: + { + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t ListFTClientsReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ListFTClientsReq"); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ListFTClientsReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ListFTClientsReq"); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ListFTClientsReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("ListFTClientsReq"); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void ListFTClientsReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t ListFTClientsReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t ListFTClientsReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t ListFTClientsReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void ListFTClientsReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t ListFTClientsReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t ListFTClientsReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t ListFTClientsReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void ListFTClientsResp::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_code: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::readWithContext(*iprot, this->code, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.code = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_leader: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::readWithContext(*iprot, this->leader, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.leader = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_clients: + { + _readState.beforeSubobject(iprot); + this->clients = ::std::vector< ::nebula::meta::cpp2::FTClient>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::FTClient>>::readWithContext(*iprot, this->clients, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.clients = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_code; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_leader; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_clients; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t ListFTClientsResp::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ListFTClientsResp"); + xfer += prot_->serializedFieldSize("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::serializedSize(*prot_, this->code); + xfer += prot_->serializedFieldSize("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->leader); + xfer += prot_->serializedFieldSize("clients", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::FTClient>>::serializedSize(*prot_, this->clients); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ListFTClientsResp::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ListFTClientsResp"); + xfer += prot_->serializedFieldSize("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::serializedSize(*prot_, this->code); + xfer += prot_->serializedFieldSize("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->leader); + xfer += prot_->serializedFieldSize("clients", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::FTClient>>::serializedSize(*prot_, this->clients); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ListFTClientsResp::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("ListFTClientsResp"); + xfer += prot_->writeFieldBegin("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::write(*prot_, this->code); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::write(*prot_, this->leader); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("clients", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::FTClient>>::write(*prot_, this->clients); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void ListFTClientsResp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t ListFTClientsResp::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t ListFTClientsResp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t ListFTClientsResp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void ListFTClientsResp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t ListFTClientsResp::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t ListFTClientsResp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t ListFTClientsResp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void FTIndex::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_space_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::readWithContext(*iprot, this->space_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.space_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_depend_schema: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::variant, ::nebula::cpp2::SchemaID>::readWithContext(*iprot, this->depend_schema, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.depend_schema = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_fields: + { + _readState.beforeSubobject(iprot); + this->fields = ::std::vector<::std::string>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>, ::std::vector<::std::string>>::readWithContext(*iprot, this->fields, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.fields = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_space_id; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_depend_schema; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_fields; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t FTIndex::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("FTIndex"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("depend_schema", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::variant, ::nebula::cpp2::SchemaID>::serializedSize(*prot_, this->depend_schema); + xfer += prot_->serializedFieldSize("fields", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>, ::std::vector<::std::string>>::serializedSize(*prot_, this->fields); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t FTIndex::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("FTIndex"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("depend_schema", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::variant, ::nebula::cpp2::SchemaID>::serializedSize(*prot_, this->depend_schema); + xfer += prot_->serializedFieldSize("fields", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>, ::std::vector<::std::string>>::serializedSize(*prot_, this->fields); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t FTIndex::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("FTIndex"); + xfer += prot_->writeFieldBegin("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::write(*prot_, this->space_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("depend_schema", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::variant, ::nebula::cpp2::SchemaID>::write(*prot_, this->depend_schema); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("fields", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>, ::std::vector<::std::string>>::write(*prot_, this->fields); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void FTIndex::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t FTIndex::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t FTIndex::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t FTIndex::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void FTIndex::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t FTIndex::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t FTIndex::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t FTIndex::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void CreateFTIndexReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_fulltext_index_name: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->fulltext_index_name, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.fulltext_index_name = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_index: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::FTIndex>::readWithContext(*iprot, this->index, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.index = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_fulltext_index_name; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_index; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t CreateFTIndexReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("CreateFTIndexReq"); + xfer += prot_->serializedFieldSize("fulltext_index_name", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->fulltext_index_name); + xfer += prot_->serializedFieldSize("index", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::FTIndex>::serializedSize(*prot_, this->index); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t CreateFTIndexReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("CreateFTIndexReq"); + xfer += prot_->serializedFieldSize("fulltext_index_name", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->fulltext_index_name); + xfer += prot_->serializedFieldSize("index", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::FTIndex>::serializedSize(*prot_, this->index); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t CreateFTIndexReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("CreateFTIndexReq"); + xfer += prot_->writeFieldBegin("fulltext_index_name", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->fulltext_index_name); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("index", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::FTIndex>::write(*prot_, this->index); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void CreateFTIndexReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t CreateFTIndexReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t CreateFTIndexReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t CreateFTIndexReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void CreateFTIndexReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t CreateFTIndexReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t CreateFTIndexReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t CreateFTIndexReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void DropFTIndexReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_space_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::readWithContext(*iprot, this->space_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.space_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_fulltext_index_name: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->fulltext_index_name, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.fulltext_index_name = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_space_id; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_fulltext_index_name; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t DropFTIndexReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("DropFTIndexReq"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("fulltext_index_name", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->fulltext_index_name); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t DropFTIndexReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("DropFTIndexReq"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("fulltext_index_name", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->fulltext_index_name); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t DropFTIndexReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("DropFTIndexReq"); + xfer += prot_->writeFieldBegin("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::write(*prot_, this->space_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("fulltext_index_name", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->fulltext_index_name); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void DropFTIndexReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t DropFTIndexReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t DropFTIndexReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t DropFTIndexReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void DropFTIndexReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t DropFTIndexReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t DropFTIndexReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t DropFTIndexReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void ListFTIndexesReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + default: + { + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t ListFTIndexesReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ListFTIndexesReq"); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ListFTIndexesReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ListFTIndexesReq"); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ListFTIndexesReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("ListFTIndexesReq"); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void ListFTIndexesReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t ListFTIndexesReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t ListFTIndexesReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t ListFTIndexesReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void ListFTIndexesReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t ListFTIndexesReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t ListFTIndexesReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t ListFTIndexesReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void ListFTIndexesResp::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_code: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::readWithContext(*iprot, this->code, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.code = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_leader: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::readWithContext(*iprot, this->leader, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.leader = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_MAP))) { + goto _loop; + } +_readField_indexes: + { + _readState.beforeSubobject(iprot); + this->indexes = std::unordered_map<::std::string, ::nebula::meta::cpp2::FTIndex>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::binary, ::apache::thrift::type_class::structure>, std::unordered_map<::std::string, ::nebula::meta::cpp2::FTIndex>>::readWithContext(*iprot, this->indexes, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.indexes = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_code; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_leader; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_MAP))) { + goto _readField_indexes; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t ListFTIndexesResp::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ListFTIndexesResp"); + xfer += prot_->serializedFieldSize("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::serializedSize(*prot_, this->code); + xfer += prot_->serializedFieldSize("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->leader); + xfer += prot_->serializedFieldSize("indexes", apache::thrift::protocol::T_MAP, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::binary, ::apache::thrift::type_class::structure>, std::unordered_map<::std::string, ::nebula::meta::cpp2::FTIndex>>::serializedSize(*prot_, this->indexes); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ListFTIndexesResp::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ListFTIndexesResp"); + xfer += prot_->serializedFieldSize("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::serializedSize(*prot_, this->code); + xfer += prot_->serializedFieldSize("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->leader); + xfer += prot_->serializedFieldSize("indexes", apache::thrift::protocol::T_MAP, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::binary, ::apache::thrift::type_class::structure>, std::unordered_map<::std::string, ::nebula::meta::cpp2::FTIndex>>::serializedSize(*prot_, this->indexes); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ListFTIndexesResp::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("ListFTIndexesResp"); + xfer += prot_->writeFieldBegin("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::write(*prot_, this->code); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::write(*prot_, this->leader); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("indexes", apache::thrift::protocol::T_MAP, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::binary, ::apache::thrift::type_class::structure>, std::unordered_map<::std::string, ::nebula::meta::cpp2::FTIndex>>::write(*prot_, this->indexes); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void ListFTIndexesResp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t ListFTIndexesResp::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t ListFTIndexesResp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t ListFTIndexesResp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void ListFTIndexesResp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t ListFTIndexesResp::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t ListFTIndexesResp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t ListFTIndexesResp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void QueryDesc::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I64))) { + goto _loop; + } +_readField_start_time: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::Timestamp>::readWithContext(*iprot, this->start_time, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.start_time = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_status: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::QueryStatus>::readWithContext(*iprot, this->status, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.status = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_I64))) { + goto _loop; + } +_readField_duration: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::readWithContext(*iprot, this->duration, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.duration = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 4, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_query: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->query, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.query = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 4, + 5, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_graph_addr: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::readWithContext(*iprot, this->graph_addr, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.graph_addr = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 5, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I64))) { + goto _readField_start_time; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_status; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I64))) { + goto _readField_duration; + } else { + goto _skip; + } + } + case 4: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_query; + } else { + goto _skip; + } + } + case 5: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_graph_addr; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t QueryDesc::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("QueryDesc"); + xfer += prot_->serializedFieldSize("start_time", apache::thrift::protocol::T_I64, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::Timestamp>::serializedSize(*prot_, this->start_time); + xfer += prot_->serializedFieldSize("status", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::QueryStatus>::serializedSize(*prot_, this->status); + xfer += prot_->serializedFieldSize("duration", apache::thrift::protocol::T_I64, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::serializedSize(*prot_, this->duration); + xfer += prot_->serializedFieldSize("query", apache::thrift::protocol::T_STRING, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->query); + xfer += prot_->serializedFieldSize("graph_addr", apache::thrift::protocol::T_STRUCT, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->graph_addr); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t QueryDesc::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("QueryDesc"); + xfer += prot_->serializedFieldSize("start_time", apache::thrift::protocol::T_I64, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::Timestamp>::serializedSize(*prot_, this->start_time); + xfer += prot_->serializedFieldSize("status", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::QueryStatus>::serializedSize(*prot_, this->status); + xfer += prot_->serializedFieldSize("duration", apache::thrift::protocol::T_I64, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::serializedSize(*prot_, this->duration); + xfer += prot_->serializedFieldSize("query", apache::thrift::protocol::T_STRING, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->query); + xfer += prot_->serializedFieldSize("graph_addr", apache::thrift::protocol::T_STRUCT, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->graph_addr); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t QueryDesc::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("QueryDesc"); + xfer += prot_->writeFieldBegin("start_time", apache::thrift::protocol::T_I64, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::Timestamp>::write(*prot_, this->start_time); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("status", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::QueryStatus>::write(*prot_, this->status); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("duration", apache::thrift::protocol::T_I64, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::write(*prot_, this->duration); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("query", apache::thrift::protocol::T_STRING, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->query); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("graph_addr", apache::thrift::protocol::T_STRUCT, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::write(*prot_, this->graph_addr); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void QueryDesc::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t QueryDesc::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t QueryDesc::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t QueryDesc::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void QueryDesc::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t QueryDesc::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t QueryDesc::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t QueryDesc::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void Session::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I64))) { + goto _loop; + } +_readField_session_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::SessionID>::readWithContext(*iprot, this->session_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.session_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_I64))) { + goto _loop; + } +_readField_create_time: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::Timestamp>::readWithContext(*iprot, this->create_time, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.create_time = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_I64))) { + goto _loop; + } +_readField_update_time: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::Timestamp>::readWithContext(*iprot, this->update_time, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.update_time = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 4, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_user_name: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->user_name, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.user_name = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 4, + 5, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_space_name: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->space_name, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.space_name = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 5, + 6, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_graph_addr: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::readWithContext(*iprot, this->graph_addr, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.graph_addr = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 6, + 7, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_timezone: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::readWithContext(*iprot, this->timezone, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.timezone = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 7, + 8, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_client_ip: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->client_ip, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.client_ip = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 8, + 9, + apache::thrift::protocol::T_MAP))) { + goto _loop; + } +_readField_configs: + { + _readState.beforeSubobject(iprot); + this->configs = std::unordered_map<::std::string, nebula::Value>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::binary, ::apache::thrift::type_class::variant>, std::unordered_map<::std::string, nebula::Value>>::readWithContext(*iprot, this->configs, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.configs = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 9, + 10, + apache::thrift::protocol::T_MAP))) { + goto _loop; + } +_readField_queries: + { + _readState.beforeSubobject(iprot); + this->queries = std::unordered_map< ::nebula::cpp2::ExecutionPlanID, ::nebula::meta::cpp2::QueryDesc>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::structure>, std::unordered_map< ::nebula::cpp2::ExecutionPlanID, ::nebula::meta::cpp2::QueryDesc>>::readWithContext(*iprot, this->queries, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.queries = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 10, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I64))) { + goto _readField_session_id; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I64))) { + goto _readField_create_time; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I64))) { + goto _readField_update_time; + } else { + goto _skip; + } + } + case 4: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_user_name; + } else { + goto _skip; + } + } + case 5: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_space_name; + } else { + goto _skip; + } + } + case 6: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_graph_addr; + } else { + goto _skip; + } + } + case 7: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_timezone; + } else { + goto _skip; + } + } + case 8: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_client_ip; + } else { + goto _skip; + } + } + case 9: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_MAP))) { + goto _readField_configs; + } else { + goto _skip; + } + } + case 10: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_MAP))) { + goto _readField_queries; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t Session::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("Session"); + xfer += prot_->serializedFieldSize("session_id", apache::thrift::protocol::T_I64, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::SessionID>::serializedSize(*prot_, this->session_id); + xfer += prot_->serializedFieldSize("create_time", apache::thrift::protocol::T_I64, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::Timestamp>::serializedSize(*prot_, this->create_time); + xfer += prot_->serializedFieldSize("update_time", apache::thrift::protocol::T_I64, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::Timestamp>::serializedSize(*prot_, this->update_time); + xfer += prot_->serializedFieldSize("user_name", apache::thrift::protocol::T_STRING, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->user_name); + xfer += prot_->serializedFieldSize("space_name", apache::thrift::protocol::T_STRING, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->space_name); + xfer += prot_->serializedFieldSize("graph_addr", apache::thrift::protocol::T_STRUCT, 6); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->graph_addr); + xfer += prot_->serializedFieldSize("timezone", apache::thrift::protocol::T_I32, 7); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::serializedSize(*prot_, this->timezone); + xfer += prot_->serializedFieldSize("client_ip", apache::thrift::protocol::T_STRING, 8); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->client_ip); + xfer += prot_->serializedFieldSize("configs", apache::thrift::protocol::T_MAP, 9); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::binary, ::apache::thrift::type_class::variant>, std::unordered_map<::std::string, nebula::Value>>::serializedSize(*prot_, this->configs); + xfer += prot_->serializedFieldSize("queries", apache::thrift::protocol::T_MAP, 10); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::structure>, std::unordered_map< ::nebula::cpp2::ExecutionPlanID, ::nebula::meta::cpp2::QueryDesc>>::serializedSize(*prot_, this->queries); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t Session::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("Session"); + xfer += prot_->serializedFieldSize("session_id", apache::thrift::protocol::T_I64, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::SessionID>::serializedSize(*prot_, this->session_id); + xfer += prot_->serializedFieldSize("create_time", apache::thrift::protocol::T_I64, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::Timestamp>::serializedSize(*prot_, this->create_time); + xfer += prot_->serializedFieldSize("update_time", apache::thrift::protocol::T_I64, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::Timestamp>::serializedSize(*prot_, this->update_time); + xfer += prot_->serializedFieldSize("user_name", apache::thrift::protocol::T_STRING, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->user_name); + xfer += prot_->serializedFieldSize("space_name", apache::thrift::protocol::T_STRING, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->space_name); + xfer += prot_->serializedFieldSize("graph_addr", apache::thrift::protocol::T_STRUCT, 6); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->graph_addr); + xfer += prot_->serializedFieldSize("timezone", apache::thrift::protocol::T_I32, 7); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::serializedSize(*prot_, this->timezone); + xfer += prot_->serializedFieldSize("client_ip", apache::thrift::protocol::T_STRING, 8); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->client_ip); + xfer += prot_->serializedFieldSize("configs", apache::thrift::protocol::T_MAP, 9); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::binary, ::apache::thrift::type_class::variant>, std::unordered_map<::std::string, nebula::Value>>::serializedSize(*prot_, this->configs); + xfer += prot_->serializedFieldSize("queries", apache::thrift::protocol::T_MAP, 10); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::structure>, std::unordered_map< ::nebula::cpp2::ExecutionPlanID, ::nebula::meta::cpp2::QueryDesc>>::serializedSize(*prot_, this->queries); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t Session::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("Session"); + xfer += prot_->writeFieldBegin("session_id", apache::thrift::protocol::T_I64, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::SessionID>::write(*prot_, this->session_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("create_time", apache::thrift::protocol::T_I64, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::Timestamp>::write(*prot_, this->create_time); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("update_time", apache::thrift::protocol::T_I64, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::Timestamp>::write(*prot_, this->update_time); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("user_name", apache::thrift::protocol::T_STRING, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->user_name); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("space_name", apache::thrift::protocol::T_STRING, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->space_name); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("graph_addr", apache::thrift::protocol::T_STRUCT, 6); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::write(*prot_, this->graph_addr); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("timezone", apache::thrift::protocol::T_I32, 7); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::write(*prot_, this->timezone); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("client_ip", apache::thrift::protocol::T_STRING, 8); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->client_ip); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("configs", apache::thrift::protocol::T_MAP, 9); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::binary, ::apache::thrift::type_class::variant>, std::unordered_map<::std::string, nebula::Value>>::write(*prot_, this->configs); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("queries", apache::thrift::protocol::T_MAP, 10); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::structure>, std::unordered_map< ::nebula::cpp2::ExecutionPlanID, ::nebula::meta::cpp2::QueryDesc>>::write(*prot_, this->queries); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void Session::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t Session::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t Session::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t Session::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void Session::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t Session::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t Session::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t Session::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void CreateSessionReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_user: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->user, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.user = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_graph_addr: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::readWithContext(*iprot, this->graph_addr, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.graph_addr = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_client_ip: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->client_ip, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.client_ip = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_user; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_graph_addr; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_client_ip; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t CreateSessionReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("CreateSessionReq"); + xfer += prot_->serializedFieldSize("user", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->user); + xfer += prot_->serializedFieldSize("graph_addr", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->graph_addr); + xfer += prot_->serializedFieldSize("client_ip", apache::thrift::protocol::T_STRING, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->client_ip); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t CreateSessionReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("CreateSessionReq"); + xfer += prot_->serializedFieldSize("user", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->user); + xfer += prot_->serializedFieldSize("graph_addr", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->graph_addr); + xfer += prot_->serializedFieldSize("client_ip", apache::thrift::protocol::T_STRING, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->client_ip); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t CreateSessionReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("CreateSessionReq"); + xfer += prot_->writeFieldBegin("user", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->user); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("graph_addr", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::write(*prot_, this->graph_addr); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("client_ip", apache::thrift::protocol::T_STRING, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->client_ip); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void CreateSessionReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t CreateSessionReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t CreateSessionReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t CreateSessionReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void CreateSessionReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t CreateSessionReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t CreateSessionReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t CreateSessionReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void CreateSessionResp::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_code: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::readWithContext(*iprot, this->code, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.code = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_leader: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::readWithContext(*iprot, this->leader, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.leader = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_session: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::Session>::readWithContext(*iprot, this->session, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.session = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_code; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_leader; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_session; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t CreateSessionResp::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("CreateSessionResp"); + xfer += prot_->serializedFieldSize("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::serializedSize(*prot_, this->code); + xfer += prot_->serializedFieldSize("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->leader); + xfer += prot_->serializedFieldSize("session", apache::thrift::protocol::T_STRUCT, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::Session>::serializedSize(*prot_, this->session); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t CreateSessionResp::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("CreateSessionResp"); + xfer += prot_->serializedFieldSize("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::serializedSize(*prot_, this->code); + xfer += prot_->serializedFieldSize("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->leader); + xfer += prot_->serializedFieldSize("session", apache::thrift::protocol::T_STRUCT, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::Session>::serializedSize(*prot_, this->session); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t CreateSessionResp::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("CreateSessionResp"); + xfer += prot_->writeFieldBegin("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::write(*prot_, this->code); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::write(*prot_, this->leader); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("session", apache::thrift::protocol::T_STRUCT, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::Session>::write(*prot_, this->session); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void CreateSessionResp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t CreateSessionResp::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t CreateSessionResp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t CreateSessionResp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void CreateSessionResp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t CreateSessionResp::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t CreateSessionResp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t CreateSessionResp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void UpdateSessionsReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_sessions: + { + _readState.beforeSubobject(iprot); + this->sessions = ::std::vector< ::nebula::meta::cpp2::Session>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::Session>>::readWithContext(*iprot, this->sessions, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.sessions = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_sessions; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t UpdateSessionsReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("UpdateSessionsReq"); + xfer += prot_->serializedFieldSize("sessions", apache::thrift::protocol::T_LIST, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::Session>>::serializedSize(*prot_, this->sessions); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t UpdateSessionsReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("UpdateSessionsReq"); + xfer += prot_->serializedFieldSize("sessions", apache::thrift::protocol::T_LIST, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::Session>>::serializedSize(*prot_, this->sessions); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t UpdateSessionsReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("UpdateSessionsReq"); + xfer += prot_->writeFieldBegin("sessions", apache::thrift::protocol::T_LIST, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::Session>>::write(*prot_, this->sessions); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void UpdateSessionsReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t UpdateSessionsReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t UpdateSessionsReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t UpdateSessionsReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void UpdateSessionsReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t UpdateSessionsReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t UpdateSessionsReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t UpdateSessionsReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void UpdateSessionsResp::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_code: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::readWithContext(*iprot, this->code, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.code = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_leader: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::readWithContext(*iprot, this->leader, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.leader = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_MAP))) { + goto _loop; + } +_readField_killed_queries: + { + _readState.beforeSubobject(iprot); + this->killed_queries = std::unordered_map< ::nebula::cpp2::SessionID, std::unordered_map< ::nebula::cpp2::ExecutionPlanID, ::nebula::meta::cpp2::QueryDesc>>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::structure>>, std::unordered_map< ::nebula::cpp2::SessionID, std::unordered_map< ::nebula::cpp2::ExecutionPlanID, ::nebula::meta::cpp2::QueryDesc>>>::readWithContext(*iprot, this->killed_queries, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.killed_queries = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_code; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_leader; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_MAP))) { + goto _readField_killed_queries; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t UpdateSessionsResp::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("UpdateSessionsResp"); + xfer += prot_->serializedFieldSize("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::serializedSize(*prot_, this->code); + xfer += prot_->serializedFieldSize("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->leader); + xfer += prot_->serializedFieldSize("killed_queries", apache::thrift::protocol::T_MAP, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::structure>>, std::unordered_map< ::nebula::cpp2::SessionID, std::unordered_map< ::nebula::cpp2::ExecutionPlanID, ::nebula::meta::cpp2::QueryDesc>>>::serializedSize(*prot_, this->killed_queries); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t UpdateSessionsResp::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("UpdateSessionsResp"); + xfer += prot_->serializedFieldSize("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::serializedSize(*prot_, this->code); + xfer += prot_->serializedFieldSize("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->leader); + xfer += prot_->serializedFieldSize("killed_queries", apache::thrift::protocol::T_MAP, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::structure>>, std::unordered_map< ::nebula::cpp2::SessionID, std::unordered_map< ::nebula::cpp2::ExecutionPlanID, ::nebula::meta::cpp2::QueryDesc>>>::serializedSize(*prot_, this->killed_queries); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t UpdateSessionsResp::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("UpdateSessionsResp"); + xfer += prot_->writeFieldBegin("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::write(*prot_, this->code); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::write(*prot_, this->leader); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("killed_queries", apache::thrift::protocol::T_MAP, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::structure>>, std::unordered_map< ::nebula::cpp2::SessionID, std::unordered_map< ::nebula::cpp2::ExecutionPlanID, ::nebula::meta::cpp2::QueryDesc>>>::write(*prot_, this->killed_queries); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void UpdateSessionsResp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t UpdateSessionsResp::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t UpdateSessionsResp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t UpdateSessionsResp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void UpdateSessionsResp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t UpdateSessionsResp::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t UpdateSessionsResp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t UpdateSessionsResp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void ListSessionsReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + default: + { + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t ListSessionsReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ListSessionsReq"); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ListSessionsReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ListSessionsReq"); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ListSessionsReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("ListSessionsReq"); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void ListSessionsReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t ListSessionsReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t ListSessionsReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t ListSessionsReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void ListSessionsReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t ListSessionsReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t ListSessionsReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t ListSessionsReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void ListSessionsResp::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_code: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::readWithContext(*iprot, this->code, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.code = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_leader: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::readWithContext(*iprot, this->leader, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.leader = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_sessions: + { + _readState.beforeSubobject(iprot); + this->sessions = ::std::vector< ::nebula::meta::cpp2::Session>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::Session>>::readWithContext(*iprot, this->sessions, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.sessions = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_code; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_leader; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_sessions; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t ListSessionsResp::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ListSessionsResp"); + xfer += prot_->serializedFieldSize("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::serializedSize(*prot_, this->code); + xfer += prot_->serializedFieldSize("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->leader); + xfer += prot_->serializedFieldSize("sessions", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::Session>>::serializedSize(*prot_, this->sessions); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ListSessionsResp::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ListSessionsResp"); + xfer += prot_->serializedFieldSize("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::serializedSize(*prot_, this->code); + xfer += prot_->serializedFieldSize("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->leader); + xfer += prot_->serializedFieldSize("sessions", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::Session>>::serializedSize(*prot_, this->sessions); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ListSessionsResp::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("ListSessionsResp"); + xfer += prot_->writeFieldBegin("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::write(*prot_, this->code); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::write(*prot_, this->leader); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("sessions", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::meta::cpp2::Session>>::write(*prot_, this->sessions); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void ListSessionsResp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t ListSessionsResp::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t ListSessionsResp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t ListSessionsResp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void ListSessionsResp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t ListSessionsResp::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t ListSessionsResp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t ListSessionsResp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void GetSessionReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I64))) { + goto _loop; + } +_readField_session_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::SessionID>::readWithContext(*iprot, this->session_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.session_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I64))) { + goto _readField_session_id; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t GetSessionReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("GetSessionReq"); + xfer += prot_->serializedFieldSize("session_id", apache::thrift::protocol::T_I64, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::SessionID>::serializedSize(*prot_, this->session_id); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t GetSessionReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("GetSessionReq"); + xfer += prot_->serializedFieldSize("session_id", apache::thrift::protocol::T_I64, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::SessionID>::serializedSize(*prot_, this->session_id); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t GetSessionReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("GetSessionReq"); + xfer += prot_->writeFieldBegin("session_id", apache::thrift::protocol::T_I64, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::SessionID>::write(*prot_, this->session_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void GetSessionReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t GetSessionReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t GetSessionReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t GetSessionReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void GetSessionReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t GetSessionReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t GetSessionReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t GetSessionReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void GetSessionResp::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_code: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::readWithContext(*iprot, this->code, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.code = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_leader: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::readWithContext(*iprot, this->leader, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.leader = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_session: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::Session>::readWithContext(*iprot, this->session, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.session = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_code; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_leader; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_session; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t GetSessionResp::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("GetSessionResp"); + xfer += prot_->serializedFieldSize("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::serializedSize(*prot_, this->code); + xfer += prot_->serializedFieldSize("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->leader); + xfer += prot_->serializedFieldSize("session", apache::thrift::protocol::T_STRUCT, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::Session>::serializedSize(*prot_, this->session); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t GetSessionResp::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("GetSessionResp"); + xfer += prot_->serializedFieldSize("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::serializedSize(*prot_, this->code); + xfer += prot_->serializedFieldSize("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->leader); + xfer += prot_->serializedFieldSize("session", apache::thrift::protocol::T_STRUCT, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::Session>::serializedSize(*prot_, this->session); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t GetSessionResp::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("GetSessionResp"); + xfer += prot_->writeFieldBegin("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::write(*prot_, this->code); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::write(*prot_, this->leader); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("session", apache::thrift::protocol::T_STRUCT, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::Session>::write(*prot_, this->session); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void GetSessionResp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t GetSessionResp::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t GetSessionResp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t GetSessionResp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void GetSessionResp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t GetSessionResp::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t GetSessionResp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t GetSessionResp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void RemoveSessionReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I64))) { + goto _loop; + } +_readField_session_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::SessionID>::readWithContext(*iprot, this->session_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.session_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I64))) { + goto _readField_session_id; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t RemoveSessionReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("RemoveSessionReq"); + xfer += prot_->serializedFieldSize("session_id", apache::thrift::protocol::T_I64, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::SessionID>::serializedSize(*prot_, this->session_id); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t RemoveSessionReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("RemoveSessionReq"); + xfer += prot_->serializedFieldSize("session_id", apache::thrift::protocol::T_I64, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::SessionID>::serializedSize(*prot_, this->session_id); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t RemoveSessionReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("RemoveSessionReq"); + xfer += prot_->writeFieldBegin("session_id", apache::thrift::protocol::T_I64, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::SessionID>::write(*prot_, this->session_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void RemoveSessionReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t RemoveSessionReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t RemoveSessionReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t RemoveSessionReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void RemoveSessionReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t RemoveSessionReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t RemoveSessionReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t RemoveSessionReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void KillQueryReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_MAP))) { + goto _loop; + } +_readField_kill_queries: + { + _readState.beforeSubobject(iprot); + this->kill_queries = std::unordered_map< ::nebula::cpp2::SessionID, std::unordered_set< ::nebula::cpp2::ExecutionPlanID>>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::set<::apache::thrift::type_class::integral>>, std::unordered_map< ::nebula::cpp2::SessionID, std::unordered_set< ::nebula::cpp2::ExecutionPlanID>>>::readWithContext(*iprot, this->kill_queries, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.kill_queries = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_MAP))) { + goto _readField_kill_queries; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t KillQueryReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("KillQueryReq"); + xfer += prot_->serializedFieldSize("kill_queries", apache::thrift::protocol::T_MAP, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::set<::apache::thrift::type_class::integral>>, std::unordered_map< ::nebula::cpp2::SessionID, std::unordered_set< ::nebula::cpp2::ExecutionPlanID>>>::serializedSize(*prot_, this->kill_queries); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t KillQueryReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("KillQueryReq"); + xfer += prot_->serializedFieldSize("kill_queries", apache::thrift::protocol::T_MAP, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::set<::apache::thrift::type_class::integral>>, std::unordered_map< ::nebula::cpp2::SessionID, std::unordered_set< ::nebula::cpp2::ExecutionPlanID>>>::serializedSize(*prot_, this->kill_queries); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t KillQueryReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("KillQueryReq"); + xfer += prot_->writeFieldBegin("kill_queries", apache::thrift::protocol::T_MAP, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::set<::apache::thrift::type_class::integral>>, std::unordered_map< ::nebula::cpp2::SessionID, std::unordered_set< ::nebula::cpp2::ExecutionPlanID>>>::write(*prot_, this->kill_queries); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void KillQueryReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t KillQueryReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t KillQueryReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t KillQueryReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void KillQueryReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t KillQueryReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t KillQueryReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t KillQueryReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void ReportTaskReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_code: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::readWithContext(*iprot, this->code, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.code = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_job_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::readWithContext(*iprot, this->job_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.job_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_task_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::readWithContext(*iprot, this->task_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.task_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 4, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_stats: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::StatsItem>::readWithContext(*iprot, this->stats, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.stats = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 4, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_code; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_job_id; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_task_id; + } else { + goto _skip; + } + } + case 4: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_stats; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t ReportTaskReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ReportTaskReq"); + xfer += prot_->serializedFieldSize("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::serializedSize(*prot_, this->code); + xfer += prot_->serializedFieldSize("job_id", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::serializedSize(*prot_, this->job_id); + xfer += prot_->serializedFieldSize("task_id", apache::thrift::protocol::T_I32, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::serializedSize(*prot_, this->task_id); + if (this->stats_ref().has_value()) { + xfer += prot_->serializedFieldSize("stats", apache::thrift::protocol::T_STRUCT, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::StatsItem>::serializedSize(*prot_, this->stats); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ReportTaskReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ReportTaskReq"); + xfer += prot_->serializedFieldSize("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::serializedSize(*prot_, this->code); + xfer += prot_->serializedFieldSize("job_id", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::serializedSize(*prot_, this->job_id); + xfer += prot_->serializedFieldSize("task_id", apache::thrift::protocol::T_I32, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::serializedSize(*prot_, this->task_id); + if (this->stats_ref().has_value()) { + xfer += prot_->serializedFieldSize("stats", apache::thrift::protocol::T_STRUCT, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::StatsItem>::serializedSize(*prot_, this->stats); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ReportTaskReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("ReportTaskReq"); + xfer += prot_->writeFieldBegin("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::write(*prot_, this->code); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("job_id", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::write(*prot_, this->job_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("task_id", apache::thrift::protocol::T_I32, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::write(*prot_, this->task_id); + xfer += prot_->writeFieldEnd(); + if (this->stats_ref().has_value()) { + xfer += prot_->writeFieldBegin("stats", apache::thrift::protocol::T_STRUCT, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::StatsItem>::write(*prot_, this->stats); + xfer += prot_->writeFieldEnd(); + } + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void ReportTaskReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t ReportTaskReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t ReportTaskReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t ReportTaskReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void ReportTaskReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t ReportTaskReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t ReportTaskReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t ReportTaskReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void ListClusterInfoResp::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_code: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::readWithContext(*iprot, this->code, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.code = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_leader: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::readWithContext(*iprot, this->leader, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.leader = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_meta_servers: + { + _readState.beforeSubobject(iprot); + this->meta_servers = ::std::vector(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector>::readWithContext(*iprot, this->meta_servers, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.meta_servers = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 4, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_storage_servers: + { + _readState.beforeSubobject(iprot); + this->storage_servers = ::std::vector< ::nebula::cpp2::NodeInfo>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::cpp2::NodeInfo>>::readWithContext(*iprot, this->storage_servers, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.storage_servers = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 4, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_code; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_leader; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_meta_servers; + } else { + goto _skip; + } + } + case 4: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_storage_servers; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t ListClusterInfoResp::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ListClusterInfoResp"); + xfer += prot_->serializedFieldSize("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::serializedSize(*prot_, this->code); + xfer += prot_->serializedFieldSize("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->leader); + xfer += prot_->serializedFieldSize("meta_servers", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector>::serializedSize(*prot_, this->meta_servers); + xfer += prot_->serializedFieldSize("storage_servers", apache::thrift::protocol::T_LIST, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::cpp2::NodeInfo>>::serializedSize(*prot_, this->storage_servers); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ListClusterInfoResp::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ListClusterInfoResp"); + xfer += prot_->serializedFieldSize("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::serializedSize(*prot_, this->code); + xfer += prot_->serializedFieldSize("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->leader); + xfer += prot_->serializedFieldSize("meta_servers", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector>::serializedSize(*prot_, this->meta_servers); + xfer += prot_->serializedFieldSize("storage_servers", apache::thrift::protocol::T_LIST, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::cpp2::NodeInfo>>::serializedSize(*prot_, this->storage_servers); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ListClusterInfoResp::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("ListClusterInfoResp"); + xfer += prot_->writeFieldBegin("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::write(*prot_, this->code); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::write(*prot_, this->leader); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("meta_servers", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector>::write(*prot_, this->meta_servers); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("storage_servers", apache::thrift::protocol::T_LIST, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::cpp2::NodeInfo>>::write(*prot_, this->storage_servers); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void ListClusterInfoResp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t ListClusterInfoResp::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t ListClusterInfoResp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t ListClusterInfoResp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void ListClusterInfoResp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t ListClusterInfoResp::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t ListClusterInfoResp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t ListClusterInfoResp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void ListClusterInfoReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + default: + { + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t ListClusterInfoReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ListClusterInfoReq"); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ListClusterInfoReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ListClusterInfoReq"); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ListClusterInfoReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("ListClusterInfoReq"); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void ListClusterInfoReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t ListClusterInfoReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t ListClusterInfoReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t ListClusterInfoReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void ListClusterInfoReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t ListClusterInfoReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t ListClusterInfoReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t ListClusterInfoReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void GetMetaDirInfoResp::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_code: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::readWithContext(*iprot, this->code, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.code = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_dir: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::cpp2::DirInfo>::readWithContext(*iprot, this->dir, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.dir = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_code; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_dir; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t GetMetaDirInfoResp::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("GetMetaDirInfoResp"); + xfer += prot_->serializedFieldSize("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::serializedSize(*prot_, this->code); + xfer += prot_->serializedFieldSize("dir", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::cpp2::DirInfo>::serializedSize(*prot_, this->dir); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t GetMetaDirInfoResp::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("GetMetaDirInfoResp"); + xfer += prot_->serializedFieldSize("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::serializedSize(*prot_, this->code); + xfer += prot_->serializedFieldSize("dir", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::cpp2::DirInfo>::serializedSize(*prot_, this->dir); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t GetMetaDirInfoResp::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("GetMetaDirInfoResp"); + xfer += prot_->writeFieldBegin("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::write(*prot_, this->code); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("dir", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::cpp2::DirInfo>::write(*prot_, this->dir); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void GetMetaDirInfoResp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t GetMetaDirInfoResp::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t GetMetaDirInfoResp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t GetMetaDirInfoResp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void GetMetaDirInfoResp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t GetMetaDirInfoResp::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t GetMetaDirInfoResp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t GetMetaDirInfoResp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void GetMetaDirInfoReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + default: + { + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t GetMetaDirInfoReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("GetMetaDirInfoReq"); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t GetMetaDirInfoReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("GetMetaDirInfoReq"); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t GetMetaDirInfoReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("GetMetaDirInfoReq"); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void GetMetaDirInfoReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t GetMetaDirInfoReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t GetMetaDirInfoReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t GetMetaDirInfoReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void GetMetaDirInfoReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t GetMetaDirInfoReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t GetMetaDirInfoReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t GetMetaDirInfoReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void VerifyClientVersionResp::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_code: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::readWithContext(*iprot, this->code, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.code = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_leader: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::readWithContext(*iprot, this->leader, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.leader = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_error_msg: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->error_msg, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.error_msg = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_code; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_leader; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_error_msg; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t VerifyClientVersionResp::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("VerifyClientVersionResp"); + xfer += prot_->serializedFieldSize("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::serializedSize(*prot_, this->code); + xfer += prot_->serializedFieldSize("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->leader); + if (this->error_msg_ref().has_value()) { + xfer += prot_->serializedFieldSize("error_msg", apache::thrift::protocol::T_STRING, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->error_msg); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t VerifyClientVersionResp::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("VerifyClientVersionResp"); + xfer += prot_->serializedFieldSize("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::serializedSize(*prot_, this->code); + xfer += prot_->serializedFieldSize("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->leader); + if (this->error_msg_ref().has_value()) { + xfer += prot_->serializedFieldSize("error_msg", apache::thrift::protocol::T_STRING, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->error_msg); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t VerifyClientVersionResp::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("VerifyClientVersionResp"); + xfer += prot_->writeFieldBegin("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::write(*prot_, this->code); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("leader", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::write(*prot_, this->leader); + xfer += prot_->writeFieldEnd(); + if (this->error_msg_ref().has_value()) { + xfer += prot_->writeFieldBegin("error_msg", apache::thrift::protocol::T_STRING, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->error_msg); + xfer += prot_->writeFieldEnd(); + } + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void VerifyClientVersionResp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t VerifyClientVersionResp::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t VerifyClientVersionResp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t VerifyClientVersionResp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void VerifyClientVersionResp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t VerifyClientVersionResp::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t VerifyClientVersionResp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t VerifyClientVersionResp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 +namespace nebula { namespace meta { namespace cpp2 { + +template +void VerifyClientVersionReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_version: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->version, _readState); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_version; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t VerifyClientVersionReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("VerifyClientVersionReq"); + xfer += prot_->serializedFieldSize("version", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->version); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t VerifyClientVersionReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("VerifyClientVersionReq"); + xfer += prot_->serializedFieldSize("version", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->version); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t VerifyClientVersionReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("VerifyClientVersionReq"); + xfer += prot_->writeFieldBegin("version", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->version); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void VerifyClientVersionReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t VerifyClientVersionReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t VerifyClientVersionReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t VerifyClientVersionReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void VerifyClientVersionReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t VerifyClientVersionReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t VerifyClientVersionReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t VerifyClientVersionReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::meta::cpp2 diff --git a/src/interface/gen-cpp2/meta_types_custom_protocol.h b/src/interface/gen-cpp2/meta_types_custom_protocol.h new file mode 100644 index 00000000..ed6eecb1 --- /dev/null +++ b/src/interface/gen-cpp2/meta_types_custom_protocol.h @@ -0,0 +1,19 @@ +/** + * Autogenerated by Thrift for meta.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#pragma once + + +/** + * This header file includes the tcc files of the corresponding header file + * and the header files of its dependent types. Include this header file + * only when you need to use custom protocols (e.g. DebugProtocol, + * VirtualProtocol) to read/write thrift structs. + */ + +#include "meta_types.tcc" + +#include "common_types_custom_protocol.h" diff --git a/src/interface/gen-cpp2/meta_visit_by_thrift_field_metadata.h b/src/interface/gen-cpp2/meta_visit_by_thrift_field_metadata.h new file mode 100644 index 00000000..ed14afc1 --- /dev/null +++ b/src/interface/gen-cpp2/meta_visit_by_thrift_field_metadata.h @@ -0,0 +1,2743 @@ +/** + * Autogenerated by Thrift for meta.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#pragma once + +#include +#include "meta_metadata.h" + +namespace apache { +namespace thrift { +namespace detail { + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::ID> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).space_id_ref()); + case 2: + return f(1, static_cast(t).tag_id_ref()); + case 3: + return f(2, static_cast(t).edge_type_ref()); + case 4: + return f(3, static_cast(t).index_id_ref()); + case 5: + return f(4, static_cast(t).cluster_id_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::ID"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::ColumnTypeDef> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).type_ref()); + case 2: + return f(1, static_cast(t).type_length_ref()); + case 3: + return f(2, static_cast(t).geo_shape_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::ColumnTypeDef"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::ColumnDef> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).name_ref()); + case 2: + return f(1, static_cast(t).type_ref()); + case 3: + return f(2, static_cast(t).default_value_ref()); + case 4: + return f(3, static_cast(t).nullable_ref()); + case 5: + return f(4, static_cast(t).comment_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::ColumnDef"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::SchemaProp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).ttl_duration_ref()); + case 2: + return f(1, static_cast(t).ttl_col_ref()); + case 3: + return f(2, static_cast(t).comment_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::SchemaProp"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::Schema> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).columns_ref()); + case 2: + return f(1, static_cast(t).schema_prop_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::Schema"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::IdName> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).id_ref()); + case 2: + return f(1, static_cast(t).name_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::IdName"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::SpaceDesc> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).space_name_ref()); + case 2: + return f(1, static_cast(t).partition_num_ref()); + case 3: + return f(2, static_cast(t).replica_factor_ref()); + case 4: + return f(3, static_cast(t).charset_name_ref()); + case 5: + return f(4, static_cast(t).collate_name_ref()); + case 6: + return f(5, static_cast(t).vid_type_ref()); + case 7: + return f(6, static_cast(t).group_name_ref()); + case 8: + return f(7, static_cast(t).isolation_level_ref()); + case 9: + return f(8, static_cast(t).comment_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::SpaceDesc"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::SpaceItem> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).space_id_ref()); + case 2: + return f(1, static_cast(t).properties_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::SpaceItem"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::TagItem> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).tag_id_ref()); + case 2: + return f(1, static_cast(t).tag_name_ref()); + case 3: + return f(2, static_cast(t).version_ref()); + case 4: + return f(3, static_cast(t).schema_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::TagItem"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::AlterSchemaItem> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).op_ref()); + case 2: + return f(1, static_cast(t).schema_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::AlterSchemaItem"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::EdgeItem> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).edge_type_ref()); + case 2: + return f(1, static_cast(t).edge_name_ref()); + case 3: + return f(2, static_cast(t).version_ref()); + case 4: + return f(3, static_cast(t).schema_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::EdgeItem"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::IndexItem> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).index_id_ref()); + case 2: + return f(1, static_cast(t).index_name_ref()); + case 3: + return f(2, static_cast(t).schema_id_ref()); + case 4: + return f(3, static_cast(t).schema_name_ref()); + case 5: + return f(4, static_cast(t).fields_ref()); + case 6: + return f(5, static_cast(t).comment_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::IndexItem"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::HostItem> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).hostAddr_ref()); + case 2: + return f(1, static_cast(t).status_ref()); + case 3: + return f(2, static_cast(t).leader_parts_ref()); + case 4: + return f(3, static_cast(t).all_parts_ref()); + case 5: + return f(4, static_cast(t).role_ref()); + case 6: + return f(5, static_cast(t).git_info_sha_ref()); + case 7: + return f(6, static_cast(t).zone_name_ref()); + case 8: + return f(7, static_cast(t).version_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::HostItem"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::UserItem> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).account_ref()); + case 2: + return f(1, static_cast(t).is_lock_ref()); + case 3: + return f(2, static_cast(t).max_queries_per_hour_ref()); + case 4: + return f(3, static_cast(t).max_updates_per_hour_ref()); + case 5: + return f(4, static_cast(t).max_connections_per_hour_ref()); + case 6: + return f(5, static_cast(t).max_user_connections_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::UserItem"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::RoleItem> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).user_id_ref()); + case 2: + return f(1, static_cast(t).space_id_ref()); + case 3: + return f(2, static_cast(t).role_type_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::RoleItem"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::ExecResp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).code_ref()); + case 2: + return f(1, static_cast(t).id_ref()); + case 3: + return f(2, static_cast(t).leader_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::ExecResp"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::AdminJobReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).op_ref()); + case 2: + return f(1, static_cast(t).cmd_ref()); + case 3: + return f(2, static_cast(t).paras_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::AdminJobReq"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::JobDesc> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).id_ref()); + case 2: + return f(1, static_cast(t).cmd_ref()); + case 3: + return f(2, static_cast(t).paras_ref()); + case 4: + return f(3, static_cast(t).status_ref()); + case 5: + return f(4, static_cast(t).start_time_ref()); + case 6: + return f(5, static_cast(t).stop_time_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::JobDesc"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::TaskDesc> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).task_id_ref()); + case 2: + return f(1, static_cast(t).host_ref()); + case 3: + return f(2, static_cast(t).status_ref()); + case 4: + return f(3, static_cast(t).start_time_ref()); + case 5: + return f(4, static_cast(t).stop_time_ref()); + case 6: + return f(5, static_cast(t).job_id_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::TaskDesc"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::AdminJobResult> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).job_id_ref()); + case 2: + return f(1, static_cast(t).job_desc_ref()); + case 3: + return f(2, static_cast(t).task_desc_ref()); + case 4: + return f(3, static_cast(t).recovered_job_num_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::AdminJobResult"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::AdminJobResp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).code_ref()); + case 2: + return f(1, static_cast(t).leader_ref()); + case 3: + return f(2, static_cast(t).result_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::AdminJobResp"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::Correlativity> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).part_id_ref()); + case 2: + return f(1, static_cast(t).proportion_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::Correlativity"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::StatsItem> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).tag_vertices_ref()); + case 2: + return f(1, static_cast(t).edges_ref()); + case 3: + return f(2, static_cast(t).space_vertices_ref()); + case 4: + return f(3, static_cast(t).space_edges_ref()); + case 5: + return f(4, static_cast(t).positive_part_correlativity_ref()); + case 6: + return f(5, static_cast(t).negative_part_correlativity_ref()); + case 7: + return f(6, static_cast(t).status_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::StatsItem"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::CreateSpaceReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).properties_ref()); + case 2: + return f(1, static_cast(t).if_not_exists_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::CreateSpaceReq"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::CreateSpaceAsReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).old_space_name_ref()); + case 2: + return f(1, static_cast(t).new_space_name_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::CreateSpaceAsReq"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::DropSpaceReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).space_name_ref()); + case 2: + return f(1, static_cast(t).if_exists_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::DropSpaceReq"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::ListSpacesReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::ListSpacesReq"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::ListSpacesResp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).code_ref()); + case 2: + return f(1, static_cast(t).leader_ref()); + case 3: + return f(2, static_cast(t).spaces_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::ListSpacesResp"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::GetSpaceReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).space_name_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::GetSpaceReq"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::GetSpaceResp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).code_ref()); + case 2: + return f(1, static_cast(t).leader_ref()); + case 3: + return f(2, static_cast(t).item_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::GetSpaceResp"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::CreateTagReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).space_id_ref()); + case 2: + return f(1, static_cast(t).tag_name_ref()); + case 3: + return f(2, static_cast(t).schema_ref()); + case 4: + return f(3, static_cast(t).if_not_exists_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::CreateTagReq"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::AlterTagReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).space_id_ref()); + case 2: + return f(1, static_cast(t).tag_name_ref()); + case 3: + return f(2, static_cast(t).tag_items_ref()); + case 4: + return f(3, static_cast(t).schema_prop_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::AlterTagReq"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::DropTagReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).space_id_ref()); + case 2: + return f(1, static_cast(t).tag_name_ref()); + case 3: + return f(2, static_cast(t).if_exists_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::DropTagReq"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::ListTagsReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).space_id_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::ListTagsReq"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::ListTagsResp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).code_ref()); + case 2: + return f(1, static_cast(t).leader_ref()); + case 3: + return f(2, static_cast(t).tags_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::ListTagsResp"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::GetTagReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).space_id_ref()); + case 2: + return f(1, static_cast(t).tag_name_ref()); + case 3: + return f(2, static_cast(t).version_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::GetTagReq"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::GetTagResp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).code_ref()); + case 2: + return f(1, static_cast(t).leader_ref()); + case 3: + return f(2, static_cast(t).schema_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::GetTagResp"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::CreateEdgeReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).space_id_ref()); + case 2: + return f(1, static_cast(t).edge_name_ref()); + case 3: + return f(2, static_cast(t).schema_ref()); + case 4: + return f(3, static_cast(t).if_not_exists_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::CreateEdgeReq"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::AlterEdgeReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).space_id_ref()); + case 2: + return f(1, static_cast(t).edge_name_ref()); + case 3: + return f(2, static_cast(t).edge_items_ref()); + case 4: + return f(3, static_cast(t).schema_prop_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::AlterEdgeReq"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::GetEdgeReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).space_id_ref()); + case 2: + return f(1, static_cast(t).edge_name_ref()); + case 3: + return f(2, static_cast(t).version_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::GetEdgeReq"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::GetEdgeResp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).code_ref()); + case 2: + return f(1, static_cast(t).leader_ref()); + case 3: + return f(2, static_cast(t).schema_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::GetEdgeResp"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::DropEdgeReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).space_id_ref()); + case 2: + return f(1, static_cast(t).edge_name_ref()); + case 3: + return f(2, static_cast(t).if_exists_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::DropEdgeReq"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::ListEdgesReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).space_id_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::ListEdgesReq"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::ListEdgesResp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).code_ref()); + case 2: + return f(1, static_cast(t).leader_ref()); + case 3: + return f(2, static_cast(t).edges_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::ListEdgesResp"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::ListHostsReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).type_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::ListHostsReq"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::ListHostsResp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).code_ref()); + case 2: + return f(1, static_cast(t).leader_ref()); + case 3: + return f(2, static_cast(t).hosts_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::ListHostsResp"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::PartItem> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).part_id_ref()); + case 2: + return f(1, static_cast(t).leader_ref()); + case 3: + return f(2, static_cast(t).peers_ref()); + case 4: + return f(3, static_cast(t).losts_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::PartItem"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::ListPartsReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).space_id_ref()); + case 2: + return f(1, static_cast(t).part_ids_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::ListPartsReq"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::ListPartsResp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).code_ref()); + case 2: + return f(1, static_cast(t).leader_ref()); + case 3: + return f(2, static_cast(t).parts_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::ListPartsResp"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::GetPartsAllocReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).space_id_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::GetPartsAllocReq"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::GetPartsAllocResp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).code_ref()); + case 2: + return f(1, static_cast(t).leader_ref()); + case 3: + return f(2, static_cast(t).parts_ref()); + case 4: + return f(3, static_cast(t).terms_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::GetPartsAllocResp"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::MultiPutReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).segment_ref()); + case 2: + return f(1, static_cast(t).pairs_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::MultiPutReq"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::GetReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).segment_ref()); + case 2: + return f(1, static_cast(t).key_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::GetReq"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::GetResp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).code_ref()); + case 2: + return f(1, static_cast(t).leader_ref()); + case 3: + return f(2, static_cast(t).value_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::GetResp"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::MultiGetReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).segment_ref()); + case 2: + return f(1, static_cast(t).keys_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::MultiGetReq"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::MultiGetResp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).code_ref()); + case 2: + return f(1, static_cast(t).leader_ref()); + case 3: + return f(2, static_cast(t).values_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::MultiGetResp"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::RemoveReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).segment_ref()); + case 2: + return f(1, static_cast(t).key_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::RemoveReq"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::RemoveRangeReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).segment_ref()); + case 2: + return f(1, static_cast(t).start_ref()); + case 3: + return f(2, static_cast(t).end_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::RemoveRangeReq"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::ScanReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).segment_ref()); + case 2: + return f(1, static_cast(t).start_ref()); + case 3: + return f(2, static_cast(t).end_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::ScanReq"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::ScanResp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).code_ref()); + case 2: + return f(1, static_cast(t).leader_ref()); + case 3: + return f(2, static_cast(t).values_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::ScanResp"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::HBResp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).code_ref()); + case 2: + return f(1, static_cast(t).leader_ref()); + case 3: + return f(2, static_cast(t).cluster_id_ref()); + case 4: + return f(3, static_cast(t).last_update_time_in_ms_ref()); + case 5: + return f(4, static_cast(t).meta_version_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::HBResp"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::LeaderInfo> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).part_id_ref()); + case 2: + return f(1, static_cast(t).term_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::LeaderInfo"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::HBReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).role_ref()); + case 2: + return f(1, static_cast(t).host_ref()); + case 3: + return f(2, static_cast(t).cluster_id_ref()); + case 4: + return f(3, static_cast(t).leader_partIds_ref()); + case 5: + return f(4, static_cast(t).git_info_sha_ref()); + case 6: + return f(5, static_cast(t).version_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::HBReq"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::IndexFieldDef> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).name_ref()); + case 2: + return f(1, static_cast(t).type_length_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::IndexFieldDef"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::CreateTagIndexReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).space_id_ref()); + case 2: + return f(1, static_cast(t).index_name_ref()); + case 3: + return f(2, static_cast(t).tag_name_ref()); + case 4: + return f(3, static_cast(t).fields_ref()); + case 5: + return f(4, static_cast(t).if_not_exists_ref()); + case 6: + return f(5, static_cast(t).comment_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::CreateTagIndexReq"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::DropTagIndexReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).space_id_ref()); + case 2: + return f(1, static_cast(t).index_name_ref()); + case 3: + return f(2, static_cast(t).if_exists_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::DropTagIndexReq"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::GetTagIndexReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).space_id_ref()); + case 2: + return f(1, static_cast(t).index_name_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::GetTagIndexReq"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::GetTagIndexResp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).code_ref()); + case 2: + return f(1, static_cast(t).leader_ref()); + case 3: + return f(2, static_cast(t).item_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::GetTagIndexResp"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::ListTagIndexesReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).space_id_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::ListTagIndexesReq"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::ListTagIndexesResp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).code_ref()); + case 2: + return f(1, static_cast(t).leader_ref()); + case 3: + return f(2, static_cast(t).items_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::ListTagIndexesResp"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::CreateEdgeIndexReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).space_id_ref()); + case 2: + return f(1, static_cast(t).index_name_ref()); + case 3: + return f(2, static_cast(t).edge_name_ref()); + case 4: + return f(3, static_cast(t).fields_ref()); + case 5: + return f(4, static_cast(t).if_not_exists_ref()); + case 6: + return f(5, static_cast(t).comment_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::CreateEdgeIndexReq"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::DropEdgeIndexReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).space_id_ref()); + case 2: + return f(1, static_cast(t).index_name_ref()); + case 3: + return f(2, static_cast(t).if_exists_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::DropEdgeIndexReq"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::GetEdgeIndexReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).space_id_ref()); + case 2: + return f(1, static_cast(t).index_name_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::GetEdgeIndexReq"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::GetEdgeIndexResp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).code_ref()); + case 2: + return f(1, static_cast(t).leader_ref()); + case 3: + return f(2, static_cast(t).item_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::GetEdgeIndexResp"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::ListEdgeIndexesReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).space_id_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::ListEdgeIndexesReq"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::ListEdgeIndexesResp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).code_ref()); + case 2: + return f(1, static_cast(t).leader_ref()); + case 3: + return f(2, static_cast(t).items_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::ListEdgeIndexesResp"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::RebuildIndexReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).space_id_ref()); + case 2: + return f(1, static_cast(t).index_name_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::RebuildIndexReq"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::CreateUserReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).account_ref()); + case 2: + return f(1, static_cast(t).encoded_pwd_ref()); + case 3: + return f(2, static_cast(t).if_not_exists_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::CreateUserReq"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::DropUserReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).account_ref()); + case 2: + return f(1, static_cast(t).if_exists_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::DropUserReq"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::AlterUserReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).account_ref()); + case 2: + return f(1, static_cast(t).encoded_pwd_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::AlterUserReq"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::GrantRoleReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).role_item_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::GrantRoleReq"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::RevokeRoleReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).role_item_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::RevokeRoleReq"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::ListUsersReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::ListUsersReq"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::ListUsersResp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).code_ref()); + case 2: + return f(1, static_cast(t).leader_ref()); + case 3: + return f(2, static_cast(t).users_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::ListUsersResp"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::ListRolesReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).space_id_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::ListRolesReq"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::ListRolesResp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).code_ref()); + case 2: + return f(1, static_cast(t).leader_ref()); + case 3: + return f(2, static_cast(t).roles_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::ListRolesResp"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::GetUserRolesReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).account_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::GetUserRolesReq"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::ChangePasswordReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).account_ref()); + case 2: + return f(1, static_cast(t).new_encoded_pwd_ref()); + case 3: + return f(2, static_cast(t).old_encoded_pwd_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::ChangePasswordReq"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::BalanceReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).space_id_ref()); + case 2: + return f(1, static_cast(t).id_ref()); + case 3: + return f(2, static_cast(t).host_del_ref()); + case 4: + return f(3, static_cast(t).stop_ref()); + case 5: + return f(4, static_cast(t).reset_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::BalanceReq"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::BalanceTask> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).id_ref()); + case 2: + return f(1, static_cast(t).result_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::BalanceTask"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::BalanceResp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).code_ref()); + case 2: + return f(1, static_cast(t).id_ref()); + case 3: + return f(2, static_cast(t).leader_ref()); + case 4: + return f(3, static_cast(t).tasks_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::BalanceResp"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::LeaderBalanceReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::LeaderBalanceReq"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::ConfigItem> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).module_ref()); + case 2: + return f(1, static_cast(t).name_ref()); + case 3: + return f(2, static_cast(t).mode_ref()); + case 4: + return f(3, static_cast(t).value_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::ConfigItem"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::RegConfigReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).items_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::RegConfigReq"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::GetConfigReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).item_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::GetConfigReq"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::GetConfigResp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).code_ref()); + case 2: + return f(1, static_cast(t).leader_ref()); + case 3: + return f(2, static_cast(t).items_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::GetConfigResp"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::SetConfigReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).item_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::SetConfigReq"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::ListConfigsReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).space_ref()); + case 2: + return f(1, static_cast(t).module_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::ListConfigsReq"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::ListConfigsResp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).code_ref()); + case 2: + return f(1, static_cast(t).leader_ref()); + case 3: + return f(2, static_cast(t).items_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::ListConfigsResp"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::CreateSnapshotReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::CreateSnapshotReq"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::DropSnapshotReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).name_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::DropSnapshotReq"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::ListSnapshotsReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::ListSnapshotsReq"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::Snapshot> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).name_ref()); + case 2: + return f(1, static_cast(t).status_ref()); + case 3: + return f(2, static_cast(t).hosts_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::Snapshot"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::ListSnapshotsResp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).code_ref()); + case 2: + return f(1, static_cast(t).leader_ref()); + case 3: + return f(2, static_cast(t).snapshots_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::ListSnapshotsResp"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::ListIndexStatusReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).space_id_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::ListIndexStatusReq"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::IndexStatus> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).name_ref()); + case 2: + return f(1, static_cast(t).status_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::IndexStatus"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::ListIndexStatusResp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).code_ref()); + case 2: + return f(1, static_cast(t).leader_ref()); + case 3: + return f(2, static_cast(t).statuses_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::ListIndexStatusResp"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::AddZoneReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).zone_name_ref()); + case 2: + return f(1, static_cast(t).nodes_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::AddZoneReq"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::DropZoneReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).zone_name_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::DropZoneReq"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::AddHostIntoZoneReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).node_ref()); + case 2: + return f(1, static_cast(t).zone_name_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::AddHostIntoZoneReq"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::DropHostFromZoneReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).node_ref()); + case 2: + return f(1, static_cast(t).zone_name_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::DropHostFromZoneReq"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::GetZoneReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).zone_name_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::GetZoneReq"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::GetZoneResp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).code_ref()); + case 2: + return f(1, static_cast(t).leader_ref()); + case 3: + return f(2, static_cast(t).hosts_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::GetZoneResp"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::ListZonesReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::ListZonesReq"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::Zone> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).zone_name_ref()); + case 2: + return f(1, static_cast(t).nodes_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::Zone"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::ListZonesResp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).code_ref()); + case 2: + return f(1, static_cast(t).leader_ref()); + case 3: + return f(2, static_cast(t).zones_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::ListZonesResp"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::AddGroupReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).group_name_ref()); + case 2: + return f(1, static_cast(t).zone_names_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::AddGroupReq"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::DropGroupReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).group_name_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::DropGroupReq"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::AddZoneIntoGroupReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).zone_name_ref()); + case 2: + return f(1, static_cast(t).group_name_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::AddZoneIntoGroupReq"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::DropZoneFromGroupReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).zone_name_ref()); + case 2: + return f(1, static_cast(t).group_name_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::DropZoneFromGroupReq"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::GetGroupReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).group_name_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::GetGroupReq"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::GetGroupResp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).code_ref()); + case 2: + return f(1, static_cast(t).leader_ref()); + case 3: + return f(2, static_cast(t).zone_names_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::GetGroupResp"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::ListGroupsReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::ListGroupsReq"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::Group> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).group_name_ref()); + case 2: + return f(1, static_cast(t).zone_names_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::Group"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::ListGroupsResp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).code_ref()); + case 2: + return f(1, static_cast(t).leader_ref()); + case 3: + return f(2, static_cast(t).groups_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::ListGroupsResp"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::AddListenerReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).space_id_ref()); + case 2: + return f(1, static_cast(t).type_ref()); + case 3: + return f(2, static_cast(t).hosts_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::AddListenerReq"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::RemoveListenerReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).space_id_ref()); + case 2: + return f(1, static_cast(t).type_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::RemoveListenerReq"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::ListListenerReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).space_id_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::ListListenerReq"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::ListenerInfo> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).type_ref()); + case 2: + return f(1, static_cast(t).host_ref()); + case 3: + return f(2, static_cast(t).part_id_ref()); + case 4: + return f(3, static_cast(t).status_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::ListenerInfo"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::ListListenerResp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).code_ref()); + case 2: + return f(1, static_cast(t).leader_ref()); + case 3: + return f(2, static_cast(t).listeners_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::ListListenerResp"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::GetStatsReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).space_id_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::GetStatsReq"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::GetStatsResp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).code_ref()); + case 2: + return f(1, static_cast(t).leader_ref()); + case 3: + return f(2, static_cast(t).stats_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::GetStatsResp"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::BackupInfo> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).host_ref()); + case 2: + return f(1, static_cast(t).info_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::BackupInfo"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::SpaceBackupInfo> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).space_ref()); + case 2: + return f(1, static_cast(t).info_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::SpaceBackupInfo"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::BackupMeta> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).backup_info_ref()); + case 2: + return f(1, static_cast(t).meta_files_ref()); + case 3: + return f(2, static_cast(t).backup_name_ref()); + case 4: + return f(3, static_cast(t).full_ref()); + case 5: + return f(4, static_cast(t).include_system_space_ref()); + case 6: + return f(5, static_cast(t).create_time_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::BackupMeta"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::CreateBackupReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).spaces_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::CreateBackupReq"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::CreateBackupResp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).code_ref()); + case 2: + return f(1, static_cast(t).leader_ref()); + case 3: + return f(2, static_cast(t).meta_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::CreateBackupResp"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::HostPair> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).from_host_ref()); + case 2: + return f(1, static_cast(t).to_host_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::HostPair"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::RestoreMetaReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).files_ref()); + case 2: + return f(1, static_cast(t).hosts_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::RestoreMetaReq"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::FTClient> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).host_ref()); + case 2: + return f(1, static_cast(t).user_ref()); + case 3: + return f(2, static_cast(t).pwd_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::FTClient"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::SignInFTServiceReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).type_ref()); + case 2: + return f(1, static_cast(t).clients_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::SignInFTServiceReq"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::SignOutFTServiceReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::SignOutFTServiceReq"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::ListFTClientsReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::ListFTClientsReq"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::ListFTClientsResp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).code_ref()); + case 2: + return f(1, static_cast(t).leader_ref()); + case 3: + return f(2, static_cast(t).clients_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::ListFTClientsResp"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::FTIndex> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).space_id_ref()); + case 2: + return f(1, static_cast(t).depend_schema_ref()); + case 3: + return f(2, static_cast(t).fields_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::FTIndex"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::CreateFTIndexReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).fulltext_index_name_ref()); + case 2: + return f(1, static_cast(t).index_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::CreateFTIndexReq"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::DropFTIndexReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).space_id_ref()); + case 2: + return f(1, static_cast(t).fulltext_index_name_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::DropFTIndexReq"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::ListFTIndexesReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::ListFTIndexesReq"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::ListFTIndexesResp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).code_ref()); + case 2: + return f(1, static_cast(t).leader_ref()); + case 3: + return f(2, static_cast(t).indexes_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::ListFTIndexesResp"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::QueryDesc> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).start_time_ref()); + case 2: + return f(1, static_cast(t).status_ref()); + case 3: + return f(2, static_cast(t).duration_ref()); + case 4: + return f(3, static_cast(t).query_ref()); + case 5: + return f(4, static_cast(t).graph_addr_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::QueryDesc"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::Session> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).session_id_ref()); + case 2: + return f(1, static_cast(t).create_time_ref()); + case 3: + return f(2, static_cast(t).update_time_ref()); + case 4: + return f(3, static_cast(t).user_name_ref()); + case 5: + return f(4, static_cast(t).space_name_ref()); + case 6: + return f(5, static_cast(t).graph_addr_ref()); + case 7: + return f(6, static_cast(t).timezone_ref()); + case 8: + return f(7, static_cast(t).client_ip_ref()); + case 9: + return f(8, static_cast(t).configs_ref()); + case 10: + return f(9, static_cast(t).queries_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::Session"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::CreateSessionReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).user_ref()); + case 2: + return f(1, static_cast(t).graph_addr_ref()); + case 3: + return f(2, static_cast(t).client_ip_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::CreateSessionReq"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::CreateSessionResp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).code_ref()); + case 2: + return f(1, static_cast(t).leader_ref()); + case 3: + return f(2, static_cast(t).session_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::CreateSessionResp"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::UpdateSessionsReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).sessions_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::UpdateSessionsReq"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::UpdateSessionsResp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).code_ref()); + case 2: + return f(1, static_cast(t).leader_ref()); + case 3: + return f(2, static_cast(t).killed_queries_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::UpdateSessionsResp"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::ListSessionsReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::ListSessionsReq"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::ListSessionsResp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).code_ref()); + case 2: + return f(1, static_cast(t).leader_ref()); + case 3: + return f(2, static_cast(t).sessions_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::ListSessionsResp"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::GetSessionReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).session_id_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::GetSessionReq"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::GetSessionResp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).code_ref()); + case 2: + return f(1, static_cast(t).leader_ref()); + case 3: + return f(2, static_cast(t).session_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::GetSessionResp"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::RemoveSessionReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).session_id_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::RemoveSessionReq"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::KillQueryReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).kill_queries_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::KillQueryReq"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::ReportTaskReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).code_ref()); + case 2: + return f(1, static_cast(t).job_id_ref()); + case 3: + return f(2, static_cast(t).task_id_ref()); + case 4: + return f(3, static_cast(t).stats_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::ReportTaskReq"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::ListClusterInfoResp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).code_ref()); + case 2: + return f(1, static_cast(t).leader_ref()); + case 3: + return f(2, static_cast(t).meta_servers_ref()); + case 4: + return f(3, static_cast(t).storage_servers_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::ListClusterInfoResp"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::ListClusterInfoReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::ListClusterInfoReq"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::GetMetaDirInfoResp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).code_ref()); + case 2: + return f(1, static_cast(t).dir_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::GetMetaDirInfoResp"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::GetMetaDirInfoReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::GetMetaDirInfoReq"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::VerifyClientVersionResp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).code_ref()); + case 2: + return f(1, static_cast(t).leader_ref()); + case 3: + return f(2, static_cast(t).error_msg_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::VerifyClientVersionResp"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::meta::cpp2::VerifyClientVersionReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).version_ref()); + default: + throwInvalidThriftId(id, "::nebula::meta::cpp2::VerifyClientVersionReq"); + } + } +}; +} // namespace detail +} // namespace thrift +} // namespace apache diff --git a/src/interface/gen-cpp2/meta_visit_union.h b/src/interface/gen-cpp2/meta_visit_union.h new file mode 100644 index 00000000..82086e51 --- /dev/null +++ b/src/interface/gen-cpp2/meta_visit_union.h @@ -0,0 +1,38 @@ +/** + * Autogenerated by Thrift for meta.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#pragma once + +#include "meta_metadata.h" +#include + +namespace apache { +namespace thrift { +namespace detail { + +template <> +struct VisitUnion<::nebula::meta::cpp2::ID> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, T&& t) const { + using Union = std::remove_reference_t; + switch (t.getType()) { + case Union::Type::space_id: + return f(0, *static_cast(t).space_id_ref()); + case Union::Type::tag_id: + return f(1, *static_cast(t).tag_id_ref()); + case Union::Type::edge_type: + return f(2, *static_cast(t).edge_type_ref()); + case Union::Type::index_id: + return f(3, *static_cast(t).index_id_ref()); + case Union::Type::cluster_id: + return f(4, *static_cast(t).cluster_id_ref()); + case Union::Type::__EMPTY__: ; + } + } +}; +} // namespace detail +} // namespace thrift +} // namespace apache diff --git a/src/interface/gen-cpp2/meta_visitation.h b/src/interface/gen-cpp2/meta_visitation.h new file mode 100644 index 00000000..6282d844 --- /dev/null +++ b/src/interface/gen-cpp2/meta_visitation.h @@ -0,0 +1,10 @@ +/** + * Autogenerated by Thrift for meta.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#pragma once +#include "common_visitation.h" +#include "meta_for_each_field.h" +#include "meta_visit_union.h" diff --git a/src/interface/gen-cpp2/storage_constants.cpp b/src/interface/gen-cpp2/storage_constants.cpp new file mode 100644 index 00000000..45ec839c --- /dev/null +++ b/src/interface/gen-cpp2/storage_constants.cpp @@ -0,0 +1,6 @@ +/** + * Autogenerated by Thrift for storage.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ diff --git a/src/interface/gen-cpp2/storage_constants.h b/src/interface/gen-cpp2/storage_constants.h new file mode 100644 index 00000000..29c69524 --- /dev/null +++ b/src/interface/gen-cpp2/storage_constants.h @@ -0,0 +1,19 @@ +/** + * Autogenerated by Thrift for storage.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#pragma once + +#include + +#include "storage_types.h" + +namespace nebula { namespace storage { namespace cpp2 { + +struct storage_constants { + +}; + +}}} // nebula::storage::cpp2 diff --git a/src/interface/gen-cpp2/storage_data.cpp b/src/interface/gen-cpp2/storage_data.cpp new file mode 100644 index 00000000..38fb21d8 --- /dev/null +++ b/src/interface/gen-cpp2/storage_data.cpp @@ -0,0 +1,1243 @@ +/** + * Autogenerated by Thrift for storage.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ + +#include "storage_data.h" + +#include + +namespace apache { +namespace thrift { + +const std::array<::nebula::storage::cpp2::StatType, 5> TEnumDataStorage<::nebula::storage::cpp2::StatType>::values = {{ + type::SUM, + type::COUNT, + type::AVG, + type::MAX, + type::MIN, +}}; +const std::array TEnumDataStorage<::nebula::storage::cpp2::StatType>::names = {{ + "SUM", + "COUNT", + "AVG", + "MAX", + "MIN", +}}; + +const std::array<::nebula::storage::cpp2::OrderDirection, 2> TEnumDataStorage<::nebula::storage::cpp2::OrderDirection>::values = {{ + type::ASCENDING, + type::DESCENDING, +}}; +const std::array TEnumDataStorage<::nebula::storage::cpp2::OrderDirection>::names = {{ + "ASCENDING", + "DESCENDING", +}}; + +const std::array<::nebula::storage::cpp2::EdgeDirection, 3> TEnumDataStorage<::nebula::storage::cpp2::EdgeDirection>::values = {{ + type::BOTH, + type::IN_EDGE, + type::OUT_EDGE, +}}; +const std::array TEnumDataStorage<::nebula::storage::cpp2::EdgeDirection>::names = {{ + "BOTH", + "IN_EDGE", + "OUT_EDGE", +}}; + +const std::array<::nebula::storage::cpp2::ScanType, 2> TEnumDataStorage<::nebula::storage::cpp2::ScanType>::values = {{ + type::PREFIX, + type::RANGE, +}}; +const std::array TEnumDataStorage<::nebula::storage::cpp2::ScanType>::names = {{ + "PREFIX", + "RANGE", +}}; + +const std::array<::nebula::storage::cpp2::EngineSignType, 2> TEnumDataStorage<::nebula::storage::cpp2::EngineSignType>::values = {{ + type::BLOCK_ON, + type::BLOCK_OFF, +}}; +const std::array TEnumDataStorage<::nebula::storage::cpp2::EngineSignType>::names = {{ + "BLOCK_ON", + "BLOCK_OFF", +}}; + +const std::array TStructDataStorage<::nebula::storage::cpp2::RequestCommon>::fields_names = {{ + "session_id", + "plan_id", + "profile_detail", +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::RequestCommon>::fields_ids = {{ + 1, + 2, + 3, +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::RequestCommon>::fields_types = {{ + TType::T_I64, + TType::T_I64, + TType::T_BOOL, +}}; + +const std::array TStructDataStorage<::nebula::storage::cpp2::PartitionResult>::fields_names = {{ + "code", + "part_id", + "leader", +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::PartitionResult>::fields_ids = {{ + 1, + 2, + 3, +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::PartitionResult>::fields_types = {{ + TType::T_I32, + TType::T_I32, + TType::T_STRUCT, +}}; + +const std::array TStructDataStorage<::nebula::storage::cpp2::ResponseCommon>::fields_names = {{ + "failed_parts", + "latency_in_us", + "latency_detail_us", +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::ResponseCommon>::fields_ids = {{ + 1, + 2, + 3, +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::ResponseCommon>::fields_types = {{ + TType::T_LIST, + TType::T_I32, + TType::T_MAP, +}}; + +const std::array TStructDataStorage<::nebula::storage::cpp2::StatProp>::fields_names = {{ + "alias", + "prop", + "stat", +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::StatProp>::fields_ids = {{ + 1, + 2, + 3, +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::StatProp>::fields_types = {{ + TType::T_STRING, + TType::T_STRING, + TType::T_I32, +}}; + +const std::array TStructDataStorage<::nebula::storage::cpp2::Expr>::fields_names = {{ + "alias", + "expr", +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::Expr>::fields_ids = {{ + 1, + 2, +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::Expr>::fields_types = {{ + TType::T_STRING, + TType::T_STRING, +}}; + +const std::array TStructDataStorage<::nebula::storage::cpp2::EdgeProp>::fields_names = {{ + "type", + "props", +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::EdgeProp>::fields_ids = {{ + 1, + 2, +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::EdgeProp>::fields_types = {{ + TType::T_I32, + TType::T_LIST, +}}; + +const std::array TStructDataStorage<::nebula::storage::cpp2::VertexProp>::fields_names = {{ + "tag", + "props", +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::VertexProp>::fields_ids = {{ + 1, + 2, +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::VertexProp>::fields_types = {{ + TType::T_I32, + TType::T_LIST, +}}; + +const std::array TStructDataStorage<::nebula::storage::cpp2::OrderBy>::fields_names = {{ + "prop", + "direction", +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::OrderBy>::fields_ids = {{ + 1, + 2, +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::OrderBy>::fields_types = {{ + TType::T_STRING, + TType::T_I32, +}}; + +const std::array TStructDataStorage<::nebula::storage::cpp2::TraverseSpec>::fields_names = {{ + "edge_types", + "edge_direction", + "dedup", + "stat_props", + "vertex_props", + "edge_props", + "expressions", + "order_by", + "random", + "limit", + "filter", +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::TraverseSpec>::fields_ids = {{ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::TraverseSpec>::fields_types = {{ + TType::T_LIST, + TType::T_I32, + TType::T_BOOL, + TType::T_LIST, + TType::T_LIST, + TType::T_LIST, + TType::T_LIST, + TType::T_LIST, + TType::T_BOOL, + TType::T_I64, + TType::T_STRING, +}}; + +const std::array TStructDataStorage<::nebula::storage::cpp2::GetNeighborsRequest>::fields_names = {{ + "space_id", + "column_names", + "parts", + "traverse_spec", + "common", +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::GetNeighborsRequest>::fields_ids = {{ + 1, + 2, + 3, + 4, + 5, +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::GetNeighborsRequest>::fields_types = {{ + TType::T_I32, + TType::T_LIST, + TType::T_MAP, + TType::T_STRUCT, + TType::T_STRUCT, +}}; + +const std::array TStructDataStorage<::nebula::storage::cpp2::GetNeighborsResponse>::fields_names = {{ + "result", + "vertices", +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::GetNeighborsResponse>::fields_ids = {{ + 1, + 2, +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::GetNeighborsResponse>::fields_types = {{ + TType::T_STRUCT, + TType::T_STRUCT, +}}; + +const std::array TStructDataStorage<::nebula::storage::cpp2::ExecResponse>::fields_names = {{ + "result", +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::ExecResponse>::fields_ids = {{ + 1, +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::ExecResponse>::fields_types = {{ + TType::T_STRUCT, +}}; + +const std::array TStructDataStorage<::nebula::storage::cpp2::GetPropRequest>::fields_names = {{ + "space_id", + "parts", + "vertex_props", + "edge_props", + "expressions", + "dedup", + "order_by", + "limit", + "filter", + "common", +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::GetPropRequest>::fields_ids = {{ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::GetPropRequest>::fields_types = {{ + TType::T_I32, + TType::T_MAP, + TType::T_LIST, + TType::T_LIST, + TType::T_LIST, + TType::T_BOOL, + TType::T_LIST, + TType::T_I64, + TType::T_STRING, + TType::T_STRUCT, +}}; + +const std::array TStructDataStorage<::nebula::storage::cpp2::GetPropResponse>::fields_names = {{ + "result", + "props", +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::GetPropResponse>::fields_ids = {{ + 1, + 2, +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::GetPropResponse>::fields_types = {{ + TType::T_STRUCT, + TType::T_STRUCT, +}}; + +const std::array TStructDataStorage<::nebula::storage::cpp2::NewTag>::fields_names = {{ + "tag_id", + "props", +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::NewTag>::fields_ids = {{ + 1, + 2, +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::NewTag>::fields_types = {{ + TType::T_I32, + TType::T_LIST, +}}; + +const std::array TStructDataStorage<::nebula::storage::cpp2::NewVertex>::fields_names = {{ + "id", + "tags", +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::NewVertex>::fields_ids = {{ + 1, + 2, +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::NewVertex>::fields_types = {{ + TType::T_STRUCT, + TType::T_LIST, +}}; + +const std::array TStructDataStorage<::nebula::storage::cpp2::EdgeKey>::fields_names = {{ + "src", + "edge_type", + "ranking", + "dst", +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::EdgeKey>::fields_ids = {{ + 1, + 2, + 3, + 4, +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::EdgeKey>::fields_types = {{ + TType::T_STRUCT, + TType::T_I32, + TType::T_I64, + TType::T_STRUCT, +}}; + +const std::array TStructDataStorage<::nebula::storage::cpp2::NewEdge>::fields_names = {{ + "key", + "props", +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::NewEdge>::fields_ids = {{ + 1, + 2, +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::NewEdge>::fields_types = {{ + TType::T_STRUCT, + TType::T_LIST, +}}; + +const std::array TStructDataStorage<::nebula::storage::cpp2::AddVerticesRequest>::fields_names = {{ + "space_id", + "parts", + "prop_names", + "if_not_exists", + "common", +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::AddVerticesRequest>::fields_ids = {{ + 1, + 2, + 3, + 4, + 5, +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::AddVerticesRequest>::fields_types = {{ + TType::T_I32, + TType::T_MAP, + TType::T_MAP, + TType::T_BOOL, + TType::T_STRUCT, +}}; + +const std::array TStructDataStorage<::nebula::storage::cpp2::AddEdgesRequest>::fields_names = {{ + "space_id", + "parts", + "prop_names", + "if_not_exists", + "common", +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::AddEdgesRequest>::fields_ids = {{ + 1, + 2, + 3, + 4, + 5, +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::AddEdgesRequest>::fields_types = {{ + TType::T_I32, + TType::T_MAP, + TType::T_LIST, + TType::T_BOOL, + TType::T_STRUCT, +}}; + +const std::array TStructDataStorage<::nebula::storage::cpp2::DeleteVerticesRequest>::fields_names = {{ + "space_id", + "parts", + "common", +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::DeleteVerticesRequest>::fields_ids = {{ + 1, + 2, + 3, +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::DeleteVerticesRequest>::fields_types = {{ + TType::T_I32, + TType::T_MAP, + TType::T_STRUCT, +}}; + +const std::array TStructDataStorage<::nebula::storage::cpp2::DeleteEdgesRequest>::fields_names = {{ + "space_id", + "parts", + "common", +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::DeleteEdgesRequest>::fields_ids = {{ + 1, + 2, + 3, +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::DeleteEdgesRequest>::fields_types = {{ + TType::T_I32, + TType::T_MAP, + TType::T_STRUCT, +}}; + +const std::array TStructDataStorage<::nebula::storage::cpp2::DelTags>::fields_names = {{ + "id", + "tags", +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::DelTags>::fields_ids = {{ + 1, + 2, +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::DelTags>::fields_types = {{ + TType::T_STRUCT, + TType::T_LIST, +}}; + +const std::array TStructDataStorage<::nebula::storage::cpp2::DeleteTagsRequest>::fields_names = {{ + "space_id", + "parts", + "common", +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::DeleteTagsRequest>::fields_ids = {{ + 1, + 2, + 3, +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::DeleteTagsRequest>::fields_types = {{ + TType::T_I32, + TType::T_MAP, + TType::T_STRUCT, +}}; + +const std::array TStructDataStorage<::nebula::storage::cpp2::UpdateResponse>::fields_names = {{ + "result", + "props", +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::UpdateResponse>::fields_ids = {{ + 1, + 2, +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::UpdateResponse>::fields_types = {{ + TType::T_STRUCT, + TType::T_STRUCT, +}}; + +const std::array TStructDataStorage<::nebula::storage::cpp2::UpdatedProp>::fields_names = {{ + "name", + "value", +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::UpdatedProp>::fields_ids = {{ + 1, + 2, +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::UpdatedProp>::fields_types = {{ + TType::T_STRING, + TType::T_STRING, +}}; + +const std::array TStructDataStorage<::nebula::storage::cpp2::UpdateVertexRequest>::fields_names = {{ + "space_id", + "part_id", + "vertex_id", + "tag_id", + "updated_props", + "insertable", + "return_props", + "condition", + "common", +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::UpdateVertexRequest>::fields_ids = {{ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::UpdateVertexRequest>::fields_types = {{ + TType::T_I32, + TType::T_I32, + TType::T_STRUCT, + TType::T_I32, + TType::T_LIST, + TType::T_BOOL, + TType::T_LIST, + TType::T_STRING, + TType::T_STRUCT, +}}; + +const std::array TStructDataStorage<::nebula::storage::cpp2::UpdateEdgeRequest>::fields_names = {{ + "space_id", + "part_id", + "edge_key", + "updated_props", + "insertable", + "return_props", + "condition", + "common", +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::UpdateEdgeRequest>::fields_ids = {{ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::UpdateEdgeRequest>::fields_types = {{ + TType::T_I32, + TType::T_I32, + TType::T_STRUCT, + TType::T_LIST, + TType::T_BOOL, + TType::T_LIST, + TType::T_STRING, + TType::T_STRUCT, +}}; + +const std::array TStructDataStorage<::nebula::storage::cpp2::GetUUIDReq>::fields_names = {{ + "space_id", + "part_id", + "name", + "common", +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::GetUUIDReq>::fields_ids = {{ + 1, + 2, + 3, + 4, +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::GetUUIDReq>::fields_types = {{ + TType::T_I32, + TType::T_I32, + TType::T_STRING, + TType::T_STRUCT, +}}; + +const std::array TStructDataStorage<::nebula::storage::cpp2::GetUUIDResp>::fields_names = {{ + "result", + "id", +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::GetUUIDResp>::fields_ids = {{ + 1, + 2, +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::GetUUIDResp>::fields_types = {{ + TType::T_STRUCT, + TType::T_STRUCT, +}}; + +const std::array TStructDataStorage<::nebula::storage::cpp2::LookupIndexResp>::fields_names = {{ + "result", + "data", +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::LookupIndexResp>::fields_ids = {{ + 1, + 2, +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::LookupIndexResp>::fields_types = {{ + TType::T_STRUCT, + TType::T_STRUCT, +}}; + +const std::array TStructDataStorage<::nebula::storage::cpp2::IndexColumnHint>::fields_names = {{ + "column_name", + "scan_type", + "begin_value", + "end_value", +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::IndexColumnHint>::fields_ids = {{ + 1, + 2, + 3, + 4, +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::IndexColumnHint>::fields_types = {{ + TType::T_STRING, + TType::T_I32, + TType::T_STRUCT, + TType::T_STRUCT, +}}; + +const std::array TStructDataStorage<::nebula::storage::cpp2::IndexQueryContext>::fields_names = {{ + "index_id", + "filter", + "column_hints", +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::IndexQueryContext>::fields_ids = {{ + 1, + 2, + 3, +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::IndexQueryContext>::fields_types = {{ + TType::T_I32, + TType::T_STRING, + TType::T_LIST, +}}; + +const std::array TStructDataStorage<::nebula::storage::cpp2::IndexSpec>::fields_names = {{ + "contexts", + "schema_id", +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::IndexSpec>::fields_ids = {{ + 1, + 2, +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::IndexSpec>::fields_types = {{ + TType::T_LIST, + TType::T_STRUCT, +}}; + +const std::array TStructDataStorage<::nebula::storage::cpp2::LookupIndexRequest>::fields_names = {{ + "space_id", + "parts", + "indices", + "return_columns", + "common", + "limit", +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::LookupIndexRequest>::fields_ids = {{ + 1, + 2, + 3, + 4, + 5, + 6, +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::LookupIndexRequest>::fields_types = {{ + TType::T_I32, + TType::T_LIST, + TType::T_STRUCT, + TType::T_LIST, + TType::T_STRUCT, + TType::T_I64, +}}; + +const std::array TStructDataStorage<::nebula::storage::cpp2::LookupAndTraverseRequest>::fields_names = {{ + "space_id", + "parts", + "indices", + "traverse_spec", + "common", +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::LookupAndTraverseRequest>::fields_ids = {{ + 1, + 2, + 3, + 4, + 5, +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::LookupAndTraverseRequest>::fields_types = {{ + TType::T_I32, + TType::T_LIST, + TType::T_STRUCT, + TType::T_STRUCT, + TType::T_STRUCT, +}}; + +const std::array TStructDataStorage<::nebula::storage::cpp2::ScanVertexRequest>::fields_names = {{ + "space_id", + "part_id", + "cursor", + "return_columns", + "limit", + "start_time", + "end_time", + "filter", + "only_latest_version", + "enable_read_from_follower", + "common", +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::ScanVertexRequest>::fields_ids = {{ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::ScanVertexRequest>::fields_types = {{ + TType::T_I32, + TType::T_I32, + TType::T_STRING, + TType::T_STRUCT, + TType::T_I64, + TType::T_I64, + TType::T_I64, + TType::T_STRING, + TType::T_BOOL, + TType::T_BOOL, + TType::T_STRUCT, +}}; + +const std::array TStructDataStorage<::nebula::storage::cpp2::ScanVertexResponse>::fields_names = {{ + "result", + "vertex_data", + "has_next", + "next_cursor", +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::ScanVertexResponse>::fields_ids = {{ + 1, + 2, + 3, + 4, +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::ScanVertexResponse>::fields_types = {{ + TType::T_STRUCT, + TType::T_STRUCT, + TType::T_BOOL, + TType::T_STRING, +}}; + +const std::array TStructDataStorage<::nebula::storage::cpp2::ScanEdgeRequest>::fields_names = {{ + "space_id", + "part_id", + "cursor", + "return_columns", + "limit", + "start_time", + "end_time", + "filter", + "only_latest_version", + "enable_read_from_follower", + "common", +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::ScanEdgeRequest>::fields_ids = {{ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::ScanEdgeRequest>::fields_types = {{ + TType::T_I32, + TType::T_I32, + TType::T_STRING, + TType::T_STRUCT, + TType::T_I64, + TType::T_I64, + TType::T_I64, + TType::T_STRING, + TType::T_BOOL, + TType::T_BOOL, + TType::T_STRUCT, +}}; + +const std::array TStructDataStorage<::nebula::storage::cpp2::ScanEdgeResponse>::fields_names = {{ + "result", + "edge_data", + "has_next", + "next_cursor", +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::ScanEdgeResponse>::fields_ids = {{ + 1, + 2, + 3, + 4, +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::ScanEdgeResponse>::fields_types = {{ + TType::T_STRUCT, + TType::T_STRUCT, + TType::T_BOOL, + TType::T_STRING, +}}; + +const std::array TStructDataStorage<::nebula::storage::cpp2::TaskPara>::fields_names = {{ + "space_id", + "parts", + "task_specfic_paras", +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::TaskPara>::fields_ids = {{ + 1, + 2, + 3, +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::TaskPara>::fields_types = {{ + TType::T_I32, + TType::T_LIST, + TType::T_LIST, +}}; + +const std::array TStructDataStorage<::nebula::storage::cpp2::AddAdminTaskRequest>::fields_names = {{ + "cmd", + "job_id", + "task_id", + "para", + "concurrency", +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::AddAdminTaskRequest>::fields_ids = {{ + 1, + 2, + 3, + 4, + 5, +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::AddAdminTaskRequest>::fields_types = {{ + TType::T_I32, + TType::T_I32, + TType::T_I32, + TType::T_STRUCT, + TType::T_I32, +}}; + +const std::array TStructDataStorage<::nebula::storage::cpp2::StopAdminTaskRequest>::fields_names = {{ + "job_id", + "task_id", +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::StopAdminTaskRequest>::fields_ids = {{ + 1, + 2, +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::StopAdminTaskRequest>::fields_types = {{ + TType::T_I32, + TType::T_I32, +}}; + +const std::array TStructDataStorage<::nebula::storage::cpp2::AdminExecResp>::fields_names = {{ + "result", + "stats", +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::AdminExecResp>::fields_ids = {{ + 1, + 2, +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::AdminExecResp>::fields_types = {{ + TType::T_STRUCT, + TType::T_STRUCT, +}}; + +const std::array TStructDataStorage<::nebula::storage::cpp2::TransLeaderReq>::fields_names = {{ + "space_id", + "part_id", + "new_leader", +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::TransLeaderReq>::fields_ids = {{ + 1, + 2, + 3, +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::TransLeaderReq>::fields_types = {{ + TType::T_I32, + TType::T_I32, + TType::T_STRUCT, +}}; + +const std::array TStructDataStorage<::nebula::storage::cpp2::AddPartReq>::fields_names = {{ + "space_id", + "part_id", + "as_learner", + "peers", +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::AddPartReq>::fields_ids = {{ + 1, + 2, + 3, + 4, +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::AddPartReq>::fields_types = {{ + TType::T_I32, + TType::T_I32, + TType::T_BOOL, + TType::T_LIST, +}}; + +const std::array TStructDataStorage<::nebula::storage::cpp2::AddLearnerReq>::fields_names = {{ + "space_id", + "part_id", + "learner", +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::AddLearnerReq>::fields_ids = {{ + 1, + 2, + 3, +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::AddLearnerReq>::fields_types = {{ + TType::T_I32, + TType::T_I32, + TType::T_STRUCT, +}}; + +const std::array TStructDataStorage<::nebula::storage::cpp2::RemovePartReq>::fields_names = {{ + "space_id", + "part_id", +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::RemovePartReq>::fields_ids = {{ + 1, + 2, +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::RemovePartReq>::fields_types = {{ + TType::T_I32, + TType::T_I32, +}}; + +const std::array TStructDataStorage<::nebula::storage::cpp2::MemberChangeReq>::fields_names = {{ + "space_id", + "part_id", + "peer", + "add", +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::MemberChangeReq>::fields_ids = {{ + 1, + 2, + 3, + 4, +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::MemberChangeReq>::fields_types = {{ + TType::T_I32, + TType::T_I32, + TType::T_STRUCT, + TType::T_BOOL, +}}; + +const std::array TStructDataStorage<::nebula::storage::cpp2::CatchUpDataReq>::fields_names = {{ + "space_id", + "part_id", + "target", +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::CatchUpDataReq>::fields_ids = {{ + 1, + 2, + 3, +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::CatchUpDataReq>::fields_types = {{ + TType::T_I32, + TType::T_I32, + TType::T_STRUCT, +}}; + +const std::array TStructDataStorage<::nebula::storage::cpp2::GetLeaderReq>::fields_names = {{ +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::GetLeaderReq>::fields_ids = {{ +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::GetLeaderReq>::fields_types = {{ +}}; + +const std::array TStructDataStorage<::nebula::storage::cpp2::CreateCPRequest>::fields_names = {{ + "space_id", + "name", +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::CreateCPRequest>::fields_ids = {{ + 1, + 2, +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::CreateCPRequest>::fields_types = {{ + TType::T_I32, + TType::T_STRING, +}}; + +const std::array TStructDataStorage<::nebula::storage::cpp2::DropCPRequest>::fields_names = {{ + "space_id", + "name", +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::DropCPRequest>::fields_ids = {{ + 1, + 2, +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::DropCPRequest>::fields_types = {{ + TType::T_I32, + TType::T_STRING, +}}; + +const std::array TStructDataStorage<::nebula::storage::cpp2::BlockingSignRequest>::fields_names = {{ + "space_id", + "sign", +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::BlockingSignRequest>::fields_ids = {{ + 1, + 2, +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::BlockingSignRequest>::fields_types = {{ + TType::T_I32, + TType::T_I32, +}}; + +const std::array TStructDataStorage<::nebula::storage::cpp2::GetLeaderPartsResp>::fields_names = {{ + "result", + "leader_parts", +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::GetLeaderPartsResp>::fields_ids = {{ + 1, + 2, +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::GetLeaderPartsResp>::fields_types = {{ + TType::T_STRUCT, + TType::T_MAP, +}}; + +const std::array TStructDataStorage<::nebula::storage::cpp2::CheckPeersReq>::fields_names = {{ + "space_id", + "part_id", + "peers", +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::CheckPeersReq>::fields_ids = {{ + 1, + 2, + 3, +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::CheckPeersReq>::fields_types = {{ + TType::T_I32, + TType::T_I32, + TType::T_LIST, +}}; + +const std::array TStructDataStorage<::nebula::storage::cpp2::RebuildIndexRequest>::fields_names = {{ + "space_id", + "parts", + "index_id", +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::RebuildIndexRequest>::fields_ids = {{ + 1, + 2, + 3, +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::RebuildIndexRequest>::fields_types = {{ + TType::T_I32, + TType::T_LIST, + TType::T_I32, +}}; + +const std::array TStructDataStorage<::nebula::storage::cpp2::CreateCPResp>::fields_names = {{ + "result", + "info", +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::CreateCPResp>::fields_ids = {{ + 1, + 2, +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::CreateCPResp>::fields_types = {{ + TType::T_STRUCT, + TType::T_LIST, +}}; + +const std::array TStructDataStorage<::nebula::storage::cpp2::ListClusterInfoResp>::fields_names = {{ + "result", + "dir", +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::ListClusterInfoResp>::fields_ids = {{ + 1, + 2, +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::ListClusterInfoResp>::fields_types = {{ + TType::T_STRUCT, + TType::T_STRUCT, +}}; + +const std::array TStructDataStorage<::nebula::storage::cpp2::ListClusterInfoReq>::fields_names = {{ +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::ListClusterInfoReq>::fields_ids = {{ +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::ListClusterInfoReq>::fields_types = {{ +}}; + +const std::array TStructDataStorage<::nebula::storage::cpp2::KVGetRequest>::fields_names = {{ + "space_id", + "parts", + "return_partly", +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::KVGetRequest>::fields_ids = {{ + 1, + 2, + 3, +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::KVGetRequest>::fields_types = {{ + TType::T_I32, + TType::T_MAP, + TType::T_BOOL, +}}; + +const std::array TStructDataStorage<::nebula::storage::cpp2::KVGetResponse>::fields_names = {{ + "result", + "key_values", +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::KVGetResponse>::fields_ids = {{ + 1, + 2, +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::KVGetResponse>::fields_types = {{ + TType::T_STRUCT, + TType::T_MAP, +}}; + +const std::array TStructDataStorage<::nebula::storage::cpp2::KVPutRequest>::fields_names = {{ + "space_id", + "parts", +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::KVPutRequest>::fields_ids = {{ + 1, + 2, +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::KVPutRequest>::fields_types = {{ + TType::T_I32, + TType::T_MAP, +}}; + +const std::array TStructDataStorage<::nebula::storage::cpp2::KVRemoveRequest>::fields_names = {{ + "space_id", + "parts", +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::KVRemoveRequest>::fields_ids = {{ + 1, + 2, +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::KVRemoveRequest>::fields_types = {{ + TType::T_I32, + TType::T_MAP, +}}; + +const std::array TStructDataStorage<::nebula::storage::cpp2::InternalTxnRequest>::fields_names = {{ + "txn_id", + "term_of_parts", + "add_edge_req", + "upd_edge_req", + "edge_ver", +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::InternalTxnRequest>::fields_ids = {{ + 1, + 2, + 3, + 4, + 5, +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::InternalTxnRequest>::fields_types = {{ + TType::T_I64, + TType::T_MAP, + TType::T_STRUCT, + TType::T_STRUCT, + TType::T_MAP, +}}; + +const std::array TStructDataStorage<::nebula::storage::cpp2::ChainAddEdgesRequest>::fields_names = {{ + "space_id", + "parts", + "prop_names", + "if_not_exists", + "term", + "edge_version", +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::ChainAddEdgesRequest>::fields_ids = {{ + 1, + 2, + 3, + 4, + 5, + 6, +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::ChainAddEdgesRequest>::fields_types = {{ + TType::T_I32, + TType::T_MAP, + TType::T_LIST, + TType::T_BOOL, + TType::T_I64, + TType::T_I64, +}}; + +const std::array TStructDataStorage<::nebula::storage::cpp2::ChainUpdateEdgeRequest>::fields_names = {{ + "update_edge_request", + "term", + "edge_version", + "space_id", + "parts", +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::ChainUpdateEdgeRequest>::fields_ids = {{ + 1, + 2, + 3, + 4, + 5, +}}; +const std::array TStructDataStorage<::nebula::storage::cpp2::ChainUpdateEdgeRequest>::fields_types = {{ + TType::T_STRUCT, + TType::T_I64, + TType::T_I64, + TType::T_I32, + TType::T_LIST, +}}; + +} // namespace thrift +} // namespace apache diff --git a/src/interface/gen-cpp2/storage_data.h b/src/interface/gen-cpp2/storage_data.h new file mode 100644 index 00000000..5a523c60 --- /dev/null +++ b/src/interface/gen-cpp2/storage_data.h @@ -0,0 +1,519 @@ +/** + * Autogenerated by Thrift for storage.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#pragma once + +#include + +#include "storage_types.h" + +namespace apache { namespace thrift { + +template <> struct TEnumDataStorage<::nebula::storage::cpp2::StatType> { + using type = ::nebula::storage::cpp2::StatType; + static constexpr const std::size_t size = 5; + static const std::array values; + static const std::array names; +}; + +template <> struct TEnumDataStorage<::nebula::storage::cpp2::OrderDirection> { + using type = ::nebula::storage::cpp2::OrderDirection; + static constexpr const std::size_t size = 2; + static const std::array values; + static const std::array names; +}; + +template <> struct TEnumDataStorage<::nebula::storage::cpp2::EdgeDirection> { + using type = ::nebula::storage::cpp2::EdgeDirection; + static constexpr const std::size_t size = 3; + static const std::array values; + static const std::array names; +}; + +template <> struct TEnumDataStorage<::nebula::storage::cpp2::ScanType> { + using type = ::nebula::storage::cpp2::ScanType; + static constexpr const std::size_t size = 2; + static const std::array values; + static const std::array names; +}; + +template <> struct TEnumDataStorage<::nebula::storage::cpp2::EngineSignType> { + using type = ::nebula::storage::cpp2::EngineSignType; + static constexpr const std::size_t size = 2; + static const std::array values; + static const std::array names; +}; + +template <> struct TStructDataStorage<::nebula::storage::cpp2::RequestCommon> { + static constexpr const std::size_t fields_size = 3; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::storage::cpp2::PartitionResult> { + static constexpr const std::size_t fields_size = 3; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::storage::cpp2::ResponseCommon> { + static constexpr const std::size_t fields_size = 3; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::storage::cpp2::StatProp> { + static constexpr const std::size_t fields_size = 3; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::storage::cpp2::Expr> { + static constexpr const std::size_t fields_size = 2; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::storage::cpp2::EdgeProp> { + static constexpr const std::size_t fields_size = 2; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::storage::cpp2::VertexProp> { + static constexpr const std::size_t fields_size = 2; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::storage::cpp2::OrderBy> { + static constexpr const std::size_t fields_size = 2; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::storage::cpp2::TraverseSpec> { + static constexpr const std::size_t fields_size = 11; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::storage::cpp2::GetNeighborsRequest> { + static constexpr const std::size_t fields_size = 5; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::storage::cpp2::GetNeighborsResponse> { + static constexpr const std::size_t fields_size = 2; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::storage::cpp2::ExecResponse> { + static constexpr const std::size_t fields_size = 1; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::storage::cpp2::GetPropRequest> { + static constexpr const std::size_t fields_size = 10; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::storage::cpp2::GetPropResponse> { + static constexpr const std::size_t fields_size = 2; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::storage::cpp2::NewTag> { + static constexpr const std::size_t fields_size = 2; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::storage::cpp2::NewVertex> { + static constexpr const std::size_t fields_size = 2; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::storage::cpp2::EdgeKey> { + static constexpr const std::size_t fields_size = 4; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::storage::cpp2::NewEdge> { + static constexpr const std::size_t fields_size = 2; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::storage::cpp2::AddVerticesRequest> { + static constexpr const std::size_t fields_size = 5; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::storage::cpp2::AddEdgesRequest> { + static constexpr const std::size_t fields_size = 5; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::storage::cpp2::DeleteVerticesRequest> { + static constexpr const std::size_t fields_size = 3; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::storage::cpp2::DeleteEdgesRequest> { + static constexpr const std::size_t fields_size = 3; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::storage::cpp2::DelTags> { + static constexpr const std::size_t fields_size = 2; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::storage::cpp2::DeleteTagsRequest> { + static constexpr const std::size_t fields_size = 3; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::storage::cpp2::UpdateResponse> { + static constexpr const std::size_t fields_size = 2; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::storage::cpp2::UpdatedProp> { + static constexpr const std::size_t fields_size = 2; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::storage::cpp2::UpdateVertexRequest> { + static constexpr const std::size_t fields_size = 9; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::storage::cpp2::UpdateEdgeRequest> { + static constexpr const std::size_t fields_size = 8; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::storage::cpp2::GetUUIDReq> { + static constexpr const std::size_t fields_size = 4; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::storage::cpp2::GetUUIDResp> { + static constexpr const std::size_t fields_size = 2; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::storage::cpp2::LookupIndexResp> { + static constexpr const std::size_t fields_size = 2; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::storage::cpp2::IndexColumnHint> { + static constexpr const std::size_t fields_size = 4; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::storage::cpp2::IndexQueryContext> { + static constexpr const std::size_t fields_size = 3; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::storage::cpp2::IndexSpec> { + static constexpr const std::size_t fields_size = 2; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::storage::cpp2::LookupIndexRequest> { + static constexpr const std::size_t fields_size = 6; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::storage::cpp2::LookupAndTraverseRequest> { + static constexpr const std::size_t fields_size = 5; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::storage::cpp2::ScanVertexRequest> { + static constexpr const std::size_t fields_size = 11; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::storage::cpp2::ScanVertexResponse> { + static constexpr const std::size_t fields_size = 4; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::storage::cpp2::ScanEdgeRequest> { + static constexpr const std::size_t fields_size = 11; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::storage::cpp2::ScanEdgeResponse> { + static constexpr const std::size_t fields_size = 4; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::storage::cpp2::TaskPara> { + static constexpr const std::size_t fields_size = 3; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::storage::cpp2::AddAdminTaskRequest> { + static constexpr const std::size_t fields_size = 5; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::storage::cpp2::StopAdminTaskRequest> { + static constexpr const std::size_t fields_size = 2; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::storage::cpp2::AdminExecResp> { + static constexpr const std::size_t fields_size = 2; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::storage::cpp2::TransLeaderReq> { + static constexpr const std::size_t fields_size = 3; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::storage::cpp2::AddPartReq> { + static constexpr const std::size_t fields_size = 4; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::storage::cpp2::AddLearnerReq> { + static constexpr const std::size_t fields_size = 3; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::storage::cpp2::RemovePartReq> { + static constexpr const std::size_t fields_size = 2; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::storage::cpp2::MemberChangeReq> { + static constexpr const std::size_t fields_size = 4; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::storage::cpp2::CatchUpDataReq> { + static constexpr const std::size_t fields_size = 3; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::storage::cpp2::GetLeaderReq> { + static constexpr const std::size_t fields_size = 0; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::storage::cpp2::CreateCPRequest> { + static constexpr const std::size_t fields_size = 2; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::storage::cpp2::DropCPRequest> { + static constexpr const std::size_t fields_size = 2; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::storage::cpp2::BlockingSignRequest> { + static constexpr const std::size_t fields_size = 2; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::storage::cpp2::GetLeaderPartsResp> { + static constexpr const std::size_t fields_size = 2; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::storage::cpp2::CheckPeersReq> { + static constexpr const std::size_t fields_size = 3; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::storage::cpp2::RebuildIndexRequest> { + static constexpr const std::size_t fields_size = 3; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::storage::cpp2::CreateCPResp> { + static constexpr const std::size_t fields_size = 2; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::storage::cpp2::ListClusterInfoResp> { + static constexpr const std::size_t fields_size = 2; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::storage::cpp2::ListClusterInfoReq> { + static constexpr const std::size_t fields_size = 0; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::storage::cpp2::KVGetRequest> { + static constexpr const std::size_t fields_size = 3; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::storage::cpp2::KVGetResponse> { + static constexpr const std::size_t fields_size = 2; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::storage::cpp2::KVPutRequest> { + static constexpr const std::size_t fields_size = 2; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::storage::cpp2::KVRemoveRequest> { + static constexpr const std::size_t fields_size = 2; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::storage::cpp2::InternalTxnRequest> { + static constexpr const std::size_t fields_size = 5; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::storage::cpp2::ChainAddEdgesRequest> { + static constexpr const std::size_t fields_size = 6; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +template <> struct TStructDataStorage<::nebula::storage::cpp2::ChainUpdateEdgeRequest> { + static constexpr const std::size_t fields_size = 5; + static const std::array fields_names; + static const std::array fields_ids; + static const std::array fields_types; +}; + +}} // apache::thrift diff --git a/src/interface/gen-cpp2/storage_for_each_field.h b/src/interface/gen-cpp2/storage_for_each_field.h new file mode 100644 index 00000000..c303d731 --- /dev/null +++ b/src/interface/gen-cpp2/storage_for_each_field.h @@ -0,0 +1,721 @@ +/** + * Autogenerated by Thrift for storage.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#pragma once + +#include "storage_metadata.h" +#include + +namespace apache { +namespace thrift { +namespace detail { + +template <> +struct ForEachField<::nebula::storage::cpp2::RequestCommon> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).session_id_ref()...); + f(1, static_cast(t).plan_id_ref()...); + f(2, static_cast(t).profile_detail_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::storage::cpp2::PartitionResult> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).code_ref()...); + f(1, static_cast(t).part_id_ref()...); + f(2, static_cast(t).leader_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::storage::cpp2::ResponseCommon> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).failed_parts_ref()...); + f(1, static_cast(t).latency_in_us_ref()...); + f(2, static_cast(t).latency_detail_us_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::storage::cpp2::StatProp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).alias_ref()...); + f(1, static_cast(t).prop_ref()...); + f(2, static_cast(t).stat_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::storage::cpp2::Expr> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).alias_ref()...); + f(1, static_cast(t).expr_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::storage::cpp2::EdgeProp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).type_ref()...); + f(1, static_cast(t).props_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::storage::cpp2::VertexProp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).tag_ref()...); + f(1, static_cast(t).props_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::storage::cpp2::OrderBy> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).prop_ref()...); + f(1, static_cast(t).direction_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::storage::cpp2::TraverseSpec> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).edge_types_ref()...); + f(1, static_cast(t).edge_direction_ref()...); + f(2, static_cast(t).dedup_ref()...); + f(3, static_cast(t).stat_props_ref()...); + f(4, static_cast(t).vertex_props_ref()...); + f(5, static_cast(t).edge_props_ref()...); + f(6, static_cast(t).expressions_ref()...); + f(7, static_cast(t).order_by_ref()...); + f(8, static_cast(t).random_ref()...); + f(9, static_cast(t).limit_ref()...); + f(10, static_cast(t).filter_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::storage::cpp2::GetNeighborsRequest> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).space_id_ref()...); + f(1, static_cast(t).column_names_ref()...); + f(2, static_cast(t).parts_ref()...); + f(3, static_cast(t).traverse_spec_ref()...); + f(4, static_cast(t).common_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::storage::cpp2::GetNeighborsResponse> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).result_ref()...); + f(1, static_cast(t).vertices_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::storage::cpp2::ExecResponse> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).result_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::storage::cpp2::GetPropRequest> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).space_id_ref()...); + f(1, static_cast(t).parts_ref()...); + f(2, static_cast(t).vertex_props_ref()...); + f(3, static_cast(t).edge_props_ref()...); + f(4, static_cast(t).expressions_ref()...); + f(5, static_cast(t).dedup_ref()...); + f(6, static_cast(t).order_by_ref()...); + f(7, static_cast(t).limit_ref()...); + f(8, static_cast(t).filter_ref()...); + f(9, static_cast(t).common_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::storage::cpp2::GetPropResponse> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).result_ref()...); + f(1, static_cast(t).props_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::storage::cpp2::NewTag> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).tag_id_ref()...); + f(1, static_cast(t).props_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::storage::cpp2::NewVertex> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).id_ref()...); + f(1, static_cast(t).tags_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::storage::cpp2::EdgeKey> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).src_ref()...); + f(1, static_cast(t).edge_type_ref()...); + f(2, static_cast(t).ranking_ref()...); + f(3, static_cast(t).dst_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::storage::cpp2::NewEdge> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).key_ref()...); + f(1, static_cast(t).props_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::storage::cpp2::AddVerticesRequest> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).space_id_ref()...); + f(1, static_cast(t).parts_ref()...); + f(2, static_cast(t).prop_names_ref()...); + f(3, static_cast(t).if_not_exists_ref()...); + f(4, static_cast(t).common_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::storage::cpp2::AddEdgesRequest> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).space_id_ref()...); + f(1, static_cast(t).parts_ref()...); + f(2, static_cast(t).prop_names_ref()...); + f(3, static_cast(t).if_not_exists_ref()...); + f(4, static_cast(t).common_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::storage::cpp2::DeleteVerticesRequest> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).space_id_ref()...); + f(1, static_cast(t).parts_ref()...); + f(2, static_cast(t).common_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::storage::cpp2::DeleteEdgesRequest> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).space_id_ref()...); + f(1, static_cast(t).parts_ref()...); + f(2, static_cast(t).common_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::storage::cpp2::DelTags> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).id_ref()...); + f(1, static_cast(t).tags_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::storage::cpp2::DeleteTagsRequest> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).space_id_ref()...); + f(1, static_cast(t).parts_ref()...); + f(2, static_cast(t).common_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::storage::cpp2::UpdateResponse> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).result_ref()...); + f(1, static_cast(t).props_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::storage::cpp2::UpdatedProp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).name_ref()...); + f(1, static_cast(t).value_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::storage::cpp2::UpdateVertexRequest> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).space_id_ref()...); + f(1, static_cast(t).part_id_ref()...); + f(2, static_cast(t).vertex_id_ref()...); + f(3, static_cast(t).tag_id_ref()...); + f(4, static_cast(t).updated_props_ref()...); + f(5, static_cast(t).insertable_ref()...); + f(6, static_cast(t).return_props_ref()...); + f(7, static_cast(t).condition_ref()...); + f(8, static_cast(t).common_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::storage::cpp2::UpdateEdgeRequest> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).space_id_ref()...); + f(1, static_cast(t).part_id_ref()...); + f(2, static_cast(t).edge_key_ref()...); + f(3, static_cast(t).updated_props_ref()...); + f(4, static_cast(t).insertable_ref()...); + f(5, static_cast(t).return_props_ref()...); + f(6, static_cast(t).condition_ref()...); + f(7, static_cast(t).common_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::storage::cpp2::GetUUIDReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).space_id_ref()...); + f(1, static_cast(t).part_id_ref()...); + f(2, static_cast(t).name_ref()...); + f(3, static_cast(t).common_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::storage::cpp2::GetUUIDResp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).result_ref()...); + f(1, static_cast(t).id_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::storage::cpp2::LookupIndexResp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).result_ref()...); + f(1, static_cast(t).data_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::storage::cpp2::IndexColumnHint> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).column_name_ref()...); + f(1, static_cast(t).scan_type_ref()...); + f(2, static_cast(t).begin_value_ref()...); + f(3, static_cast(t).end_value_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::storage::cpp2::IndexQueryContext> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).index_id_ref()...); + f(1, static_cast(t).filter_ref()...); + f(2, static_cast(t).column_hints_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::storage::cpp2::IndexSpec> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).contexts_ref()...); + f(1, static_cast(t).schema_id_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::storage::cpp2::LookupIndexRequest> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).space_id_ref()...); + f(1, static_cast(t).parts_ref()...); + f(2, static_cast(t).indices_ref()...); + f(3, static_cast(t).return_columns_ref()...); + f(4, static_cast(t).common_ref()...); + f(5, static_cast(t).limit_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::storage::cpp2::LookupAndTraverseRequest> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).space_id_ref()...); + f(1, static_cast(t).parts_ref()...); + f(2, static_cast(t).indices_ref()...); + f(3, static_cast(t).traverse_spec_ref()...); + f(4, static_cast(t).common_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::storage::cpp2::ScanVertexRequest> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).space_id_ref()...); + f(1, static_cast(t).part_id_ref()...); + f(2, static_cast(t).cursor_ref()...); + f(3, static_cast(t).return_columns_ref()...); + f(4, static_cast(t).limit_ref()...); + f(5, static_cast(t).start_time_ref()...); + f(6, static_cast(t).end_time_ref()...); + f(7, static_cast(t).filter_ref()...); + f(8, static_cast(t).only_latest_version_ref()...); + f(9, static_cast(t).enable_read_from_follower_ref()...); + f(10, static_cast(t).common_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::storage::cpp2::ScanVertexResponse> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).result_ref()...); + f(1, static_cast(t).vertex_data_ref()...); + f(2, static_cast(t).has_next_ref()...); + f(3, static_cast(t).next_cursor_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::storage::cpp2::ScanEdgeRequest> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).space_id_ref()...); + f(1, static_cast(t).part_id_ref()...); + f(2, static_cast(t).cursor_ref()...); + f(3, static_cast(t).return_columns_ref()...); + f(4, static_cast(t).limit_ref()...); + f(5, static_cast(t).start_time_ref()...); + f(6, static_cast(t).end_time_ref()...); + f(7, static_cast(t).filter_ref()...); + f(8, static_cast(t).only_latest_version_ref()...); + f(9, static_cast(t).enable_read_from_follower_ref()...); + f(10, static_cast(t).common_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::storage::cpp2::ScanEdgeResponse> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).result_ref()...); + f(1, static_cast(t).edge_data_ref()...); + f(2, static_cast(t).has_next_ref()...); + f(3, static_cast(t).next_cursor_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::storage::cpp2::TaskPara> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).space_id_ref()...); + f(1, static_cast(t).parts_ref()...); + f(2, static_cast(t).task_specfic_paras_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::storage::cpp2::AddAdminTaskRequest> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).cmd_ref()...); + f(1, static_cast(t).job_id_ref()...); + f(2, static_cast(t).task_id_ref()...); + f(3, static_cast(t).para_ref()...); + f(4, static_cast(t).concurrency_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::storage::cpp2::StopAdminTaskRequest> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).job_id_ref()...); + f(1, static_cast(t).task_id_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::storage::cpp2::AdminExecResp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).result_ref()...); + f(1, static_cast(t).stats_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::storage::cpp2::TransLeaderReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).space_id_ref()...); + f(1, static_cast(t).part_id_ref()...); + f(2, static_cast(t).new_leader_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::storage::cpp2::AddPartReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).space_id_ref()...); + f(1, static_cast(t).part_id_ref()...); + f(2, static_cast(t).as_learner_ref()...); + f(3, static_cast(t).peers_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::storage::cpp2::AddLearnerReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).space_id_ref()...); + f(1, static_cast(t).part_id_ref()...); + f(2, static_cast(t).learner_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::storage::cpp2::RemovePartReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).space_id_ref()...); + f(1, static_cast(t).part_id_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::storage::cpp2::MemberChangeReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).space_id_ref()...); + f(1, static_cast(t).part_id_ref()...); + f(2, static_cast(t).peer_ref()...); + f(3, static_cast(t).add_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::storage::cpp2::CatchUpDataReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).space_id_ref()...); + f(1, static_cast(t).part_id_ref()...); + f(2, static_cast(t).target_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::storage::cpp2::GetLeaderReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + } +}; + +template <> +struct ForEachField<::nebula::storage::cpp2::CreateCPRequest> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).space_id_ref()...); + f(1, static_cast(t).name_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::storage::cpp2::DropCPRequest> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).space_id_ref()...); + f(1, static_cast(t).name_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::storage::cpp2::BlockingSignRequest> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).space_id_ref()...); + f(1, static_cast(t).sign_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::storage::cpp2::GetLeaderPartsResp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).result_ref()...); + f(1, static_cast(t).leader_parts_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::storage::cpp2::CheckPeersReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).space_id_ref()...); + f(1, static_cast(t).part_id_ref()...); + f(2, static_cast(t).peers_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::storage::cpp2::RebuildIndexRequest> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).space_id_ref()...); + f(1, static_cast(t).parts_ref()...); + f(2, static_cast(t).index_id_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::storage::cpp2::CreateCPResp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).result_ref()...); + f(1, static_cast(t).info_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::storage::cpp2::ListClusterInfoResp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).result_ref()...); + f(1, static_cast(t).dir_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::storage::cpp2::ListClusterInfoReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + } +}; + +template <> +struct ForEachField<::nebula::storage::cpp2::KVGetRequest> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).space_id_ref()...); + f(1, static_cast(t).parts_ref()...); + f(2, static_cast(t).return_partly_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::storage::cpp2::KVGetResponse> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).result_ref()...); + f(1, static_cast(t).key_values_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::storage::cpp2::KVPutRequest> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).space_id_ref()...); + f(1, static_cast(t).parts_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::storage::cpp2::KVRemoveRequest> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).space_id_ref()...); + f(1, static_cast(t).parts_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::storage::cpp2::InternalTxnRequest> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).txn_id_ref()...); + f(1, static_cast(t).term_of_parts_ref()...); + f(2, static_cast(t).add_edge_req_ref()...); + f(3, static_cast(t).upd_edge_req_ref()...); + f(4, static_cast(t).edge_ver_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::storage::cpp2::ChainAddEdgesRequest> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).space_id_ref()...); + f(1, static_cast(t).parts_ref()...); + f(2, static_cast(t).prop_names_ref()...); + f(3, static_cast(t).if_not_exists_ref()...); + f(4, static_cast(t).term_ref()...); + f(5, static_cast(t).edge_version_ref()...); + } +}; + +template <> +struct ForEachField<::nebula::storage::cpp2::ChainUpdateEdgeRequest> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, FOLLY_MAYBE_UNUSED T&&... t) const { + f(0, static_cast(t).update_edge_request_ref()...); + f(1, static_cast(t).term_ref()...); + f(2, static_cast(t).edge_version_ref()...); + f(3, static_cast(t).space_id_ref()...); + f(4, static_cast(t).parts_ref()...); + } +}; +} // namespace detail +} // namespace thrift +} // namespace apache diff --git a/src/interface/gen-cpp2/storage_metadata.cpp b/src/interface/gen-cpp2/storage_metadata.cpp new file mode 100644 index 00000000..741599a7 --- /dev/null +++ b/src/interface/gen-cpp2/storage_metadata.cpp @@ -0,0 +1,2527 @@ +/** + * Autogenerated by Thrift for storage.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#include +#include "storage_metadata.h" + +namespace apache { +namespace thrift { +namespace detail { +namespace md { +using ThriftMetadata = ::apache::thrift::metadata::ThriftMetadata; +using ThriftPrimitiveType = ::apache::thrift::metadata::ThriftPrimitiveType; +using ThriftType = ::apache::thrift::metadata::ThriftType; +using ThriftService = ::apache::thrift::metadata::ThriftService; +using ThriftServiceContext = ::apache::thrift::metadata::ThriftServiceContext; +using ThriftFunctionGenerator = void (*)(ThriftMetadata&, ThriftService&); + +void EnumMetadata<::nebula::storage::cpp2::StatType>::gen(ThriftMetadata& metadata) { + auto res = metadata.enums_ref()->emplace("storage.StatType", ::apache::thrift::metadata::ThriftEnum{}); + if (!res.second) { + return; + } + ::apache::thrift::metadata::ThriftEnum& enum_metadata = res.first->second; + enum_metadata.name_ref() = "storage.StatType"; + using EnumTraits = TEnumTraits<::nebula::storage::cpp2::StatType>; + for (std::size_t i = 0; i < EnumTraits::size; ++i) { + enum_metadata.elements_ref()->emplace(static_cast(EnumTraits::values[i]), EnumTraits::names[i].str()); + } +} +void EnumMetadata<::nebula::storage::cpp2::OrderDirection>::gen(ThriftMetadata& metadata) { + auto res = metadata.enums_ref()->emplace("storage.OrderDirection", ::apache::thrift::metadata::ThriftEnum{}); + if (!res.second) { + return; + } + ::apache::thrift::metadata::ThriftEnum& enum_metadata = res.first->second; + enum_metadata.name_ref() = "storage.OrderDirection"; + using EnumTraits = TEnumTraits<::nebula::storage::cpp2::OrderDirection>; + for (std::size_t i = 0; i < EnumTraits::size; ++i) { + enum_metadata.elements_ref()->emplace(static_cast(EnumTraits::values[i]), EnumTraits::names[i].str()); + } +} +void EnumMetadata<::nebula::storage::cpp2::EdgeDirection>::gen(ThriftMetadata& metadata) { + auto res = metadata.enums_ref()->emplace("storage.EdgeDirection", ::apache::thrift::metadata::ThriftEnum{}); + if (!res.second) { + return; + } + ::apache::thrift::metadata::ThriftEnum& enum_metadata = res.first->second; + enum_metadata.name_ref() = "storage.EdgeDirection"; + using EnumTraits = TEnumTraits<::nebula::storage::cpp2::EdgeDirection>; + for (std::size_t i = 0; i < EnumTraits::size; ++i) { + enum_metadata.elements_ref()->emplace(static_cast(EnumTraits::values[i]), EnumTraits::names[i].str()); + } +} +void EnumMetadata<::nebula::storage::cpp2::ScanType>::gen(ThriftMetadata& metadata) { + auto res = metadata.enums_ref()->emplace("storage.ScanType", ::apache::thrift::metadata::ThriftEnum{}); + if (!res.second) { + return; + } + ::apache::thrift::metadata::ThriftEnum& enum_metadata = res.first->second; + enum_metadata.name_ref() = "storage.ScanType"; + using EnumTraits = TEnumTraits<::nebula::storage::cpp2::ScanType>; + for (std::size_t i = 0; i < EnumTraits::size; ++i) { + enum_metadata.elements_ref()->emplace(static_cast(EnumTraits::values[i]), EnumTraits::names[i].str()); + } +} +void EnumMetadata<::nebula::storage::cpp2::EngineSignType>::gen(ThriftMetadata& metadata) { + auto res = metadata.enums_ref()->emplace("storage.EngineSignType", ::apache::thrift::metadata::ThriftEnum{}); + if (!res.second) { + return; + } + ::apache::thrift::metadata::ThriftEnum& enum_metadata = res.first->second; + enum_metadata.name_ref() = "storage.EngineSignType"; + using EnumTraits = TEnumTraits<::nebula::storage::cpp2::EngineSignType>; + for (std::size_t i = 0; i < EnumTraits::size; ++i) { + enum_metadata.elements_ref()->emplace(static_cast(EnumTraits::values[i]), EnumTraits::names[i].str()); + } +} + +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::storage::cpp2::RequestCommon>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("storage.RequestCommon", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& storage_RequestCommon = res.first->second; + storage_RequestCommon.name_ref() = "storage.RequestCommon"; + storage_RequestCommon.is_union_ref() = false; + static const EncodedThriftField + storage_RequestCommon_fields[] = { + std::make_tuple(1, "session_id", true, std::make_unique("common.SessionID", std::make_unique(ThriftPrimitiveType::THRIFT_I64_TYPE)), std::vector{}), + std::make_tuple(2, "plan_id", true, std::make_unique("common.ExecutionPlanID", std::make_unique(ThriftPrimitiveType::THRIFT_I64_TYPE)), std::vector{}), + std::make_tuple(3, "profile_detail", true, std::make_unique(ThriftPrimitiveType::THRIFT_BOOL_TYPE), std::vector{}), + }; + for (const auto& f : storage_RequestCommon_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + storage_RequestCommon.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::storage::cpp2::PartitionResult>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("storage.PartitionResult", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& storage_PartitionResult = res.first->second; + storage_PartitionResult.name_ref() = "storage.PartitionResult"; + storage_PartitionResult.is_union_ref() = false; + static const EncodedThriftField + storage_PartitionResult_fields[] = { + std::make_tuple(1, "code", false, std::make_unique>("common.ErrorCode"), std::vector{}), + std::make_tuple(2, "part_id", false, std::make_unique("common.PartitionID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + std::make_tuple(3, "leader", true, std::make_unique>("common.HostAddr"), std::vector{}), + }; + for (const auto& f : storage_PartitionResult_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + storage_PartitionResult.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::storage::cpp2::ResponseCommon>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("storage.ResponseCommon", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& storage_ResponseCommon = res.first->second; + storage_ResponseCommon.name_ref() = "storage.ResponseCommon"; + storage_ResponseCommon.is_union_ref() = false; + static const EncodedThriftField + storage_ResponseCommon_fields[] = { + std::make_tuple(1, "failed_parts", false, std::make_unique(std::make_unique>("storage.PartitionResult")), std::vector{}), + std::make_tuple(2, "latency_in_us", false, std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE), std::vector{}), + std::make_tuple(3, "latency_detail_us", true, std::make_unique(std::make_unique(ThriftPrimitiveType::THRIFT_STRING_TYPE), std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + }; + for (const auto& f : storage_ResponseCommon_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + storage_ResponseCommon.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::storage::cpp2::StatProp>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("storage.StatProp", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& storage_StatProp = res.first->second; + storage_StatProp.name_ref() = "storage.StatProp"; + storage_StatProp.is_union_ref() = false; + static const EncodedThriftField + storage_StatProp_fields[] = { + std::make_tuple(1, "alias", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + std::make_tuple(2, "prop", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + std::make_tuple(3, "stat", false, std::make_unique>("storage.StatType"), std::vector{}), + }; + for (const auto& f : storage_StatProp_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + storage_StatProp.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::storage::cpp2::Expr>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("storage.Expr", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& storage_Expr = res.first->second; + storage_Expr.name_ref() = "storage.Expr"; + storage_Expr.is_union_ref() = false; + static const EncodedThriftField + storage_Expr_fields[] = { + std::make_tuple(1, "alias", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + std::make_tuple(2, "expr", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + }; + for (const auto& f : storage_Expr_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + storage_Expr.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::storage::cpp2::EdgeProp>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("storage.EdgeProp", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& storage_EdgeProp = res.first->second; + storage_EdgeProp.name_ref() = "storage.EdgeProp"; + storage_EdgeProp.is_union_ref() = false; + static const EncodedThriftField + storage_EdgeProp_fields[] = { + std::make_tuple(1, "type", false, std::make_unique("common.EdgeType", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + std::make_tuple(2, "props", false, std::make_unique(std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE)), std::vector{}), + }; + for (const auto& f : storage_EdgeProp_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + storage_EdgeProp.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::storage::cpp2::VertexProp>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("storage.VertexProp", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& storage_VertexProp = res.first->second; + storage_VertexProp.name_ref() = "storage.VertexProp"; + storage_VertexProp.is_union_ref() = false; + static const EncodedThriftField + storage_VertexProp_fields[] = { + std::make_tuple(1, "tag", false, std::make_unique("common.TagID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + std::make_tuple(2, "props", false, std::make_unique(std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE)), std::vector{}), + }; + for (const auto& f : storage_VertexProp_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + storage_VertexProp.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::storage::cpp2::OrderBy>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("storage.OrderBy", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& storage_OrderBy = res.first->second; + storage_OrderBy.name_ref() = "storage.OrderBy"; + storage_OrderBy.is_union_ref() = false; + static const EncodedThriftField + storage_OrderBy_fields[] = { + std::make_tuple(1, "prop", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + std::make_tuple(2, "direction", false, std::make_unique>("storage.OrderDirection"), std::vector{}), + }; + for (const auto& f : storage_OrderBy_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + storage_OrderBy.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::storage::cpp2::TraverseSpec>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("storage.TraverseSpec", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& storage_TraverseSpec = res.first->second; + storage_TraverseSpec.name_ref() = "storage.TraverseSpec"; + storage_TraverseSpec.is_union_ref() = false; + static const EncodedThriftField + storage_TraverseSpec_fields[] = { + std::make_tuple(1, "edge_types", false, std::make_unique(std::make_unique("common.EdgeType", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE))), std::vector{}), + std::make_tuple(2, "edge_direction", false, std::make_unique>("storage.EdgeDirection"), std::vector{}), + std::make_tuple(3, "dedup", false, std::make_unique(ThriftPrimitiveType::THRIFT_BOOL_TYPE), std::vector{}), + std::make_tuple(4, "stat_props", true, std::make_unique(std::make_unique>("storage.StatProp")), std::vector{}), + std::make_tuple(5, "vertex_props", true, std::make_unique(std::make_unique>("storage.VertexProp")), std::vector{}), + std::make_tuple(6, "edge_props", true, std::make_unique(std::make_unique>("storage.EdgeProp")), std::vector{}), + std::make_tuple(7, "expressions", true, std::make_unique(std::make_unique>("storage.Expr")), std::vector{}), + std::make_tuple(8, "order_by", true, std::make_unique(std::make_unique>("storage.OrderBy")), std::vector{}), + std::make_tuple(9, "random", true, std::make_unique(ThriftPrimitiveType::THRIFT_BOOL_TYPE), std::vector{}), + std::make_tuple(10, "limit", true, std::make_unique(ThriftPrimitiveType::THRIFT_I64_TYPE), std::vector{}), + std::make_tuple(11, "filter", true, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + }; + for (const auto& f : storage_TraverseSpec_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + storage_TraverseSpec.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::storage::cpp2::GetNeighborsRequest>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("storage.GetNeighborsRequest", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& storage_GetNeighborsRequest = res.first->second; + storage_GetNeighborsRequest.name_ref() = "storage.GetNeighborsRequest"; + storage_GetNeighborsRequest.is_union_ref() = false; + static const EncodedThriftField + storage_GetNeighborsRequest_fields[] = { + std::make_tuple(1, "space_id", false, std::make_unique("common.GraphSpaceID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + std::make_tuple(2, "column_names", false, std::make_unique(std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE)), std::vector{}), + std::make_tuple(3, "parts", false, std::make_unique(std::make_unique("common.PartitionID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::make_unique(std::make_unique>("common.Row"))), std::vector{}), + std::make_tuple(4, "traverse_spec", false, std::make_unique>("storage.TraverseSpec"), std::vector{}), + std::make_tuple(5, "common", true, std::make_unique>("storage.RequestCommon"), std::vector{}), + }; + for (const auto& f : storage_GetNeighborsRequest_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + storage_GetNeighborsRequest.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::storage::cpp2::GetNeighborsResponse>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("storage.GetNeighborsResponse", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& storage_GetNeighborsResponse = res.first->second; + storage_GetNeighborsResponse.name_ref() = "storage.GetNeighborsResponse"; + storage_GetNeighborsResponse.is_union_ref() = false; + static const EncodedThriftField + storage_GetNeighborsResponse_fields[] = { + std::make_tuple(1, "result", false, std::make_unique>("storage.ResponseCommon"), std::vector{}), + std::make_tuple(2, "vertices", true, std::make_unique>("common.DataSet"), std::vector{}), + }; + for (const auto& f : storage_GetNeighborsResponse_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + storage_GetNeighborsResponse.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::storage::cpp2::ExecResponse>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("storage.ExecResponse", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& storage_ExecResponse = res.first->second; + storage_ExecResponse.name_ref() = "storage.ExecResponse"; + storage_ExecResponse.is_union_ref() = false; + static const EncodedThriftField + storage_ExecResponse_fields[] = { + std::make_tuple(1, "result", false, std::make_unique>("storage.ResponseCommon"), std::vector{}), + }; + for (const auto& f : storage_ExecResponse_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + storage_ExecResponse.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::storage::cpp2::GetPropRequest>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("storage.GetPropRequest", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& storage_GetPropRequest = res.first->second; + storage_GetPropRequest.name_ref() = "storage.GetPropRequest"; + storage_GetPropRequest.is_union_ref() = false; + static const EncodedThriftField + storage_GetPropRequest_fields[] = { + std::make_tuple(1, "space_id", false, std::make_unique("common.GraphSpaceID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + std::make_tuple(2, "parts", false, std::make_unique(std::make_unique("common.PartitionID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::make_unique(std::make_unique>("common.Row"))), std::vector{}), + std::make_tuple(3, "vertex_props", true, std::make_unique(std::make_unique>("storage.VertexProp")), std::vector{}), + std::make_tuple(4, "edge_props", true, std::make_unique(std::make_unique>("storage.EdgeProp")), std::vector{}), + std::make_tuple(5, "expressions", true, std::make_unique(std::make_unique>("storage.Expr")), std::vector{}), + std::make_tuple(6, "dedup", false, std::make_unique(ThriftPrimitiveType::THRIFT_BOOL_TYPE), std::vector{}), + std::make_tuple(7, "order_by", true, std::make_unique(std::make_unique>("storage.OrderBy")), std::vector{}), + std::make_tuple(8, "limit", true, std::make_unique(ThriftPrimitiveType::THRIFT_I64_TYPE), std::vector{}), + std::make_tuple(9, "filter", true, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + std::make_tuple(10, "common", true, std::make_unique>("storage.RequestCommon"), std::vector{}), + }; + for (const auto& f : storage_GetPropRequest_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + storage_GetPropRequest.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::storage::cpp2::GetPropResponse>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("storage.GetPropResponse", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& storage_GetPropResponse = res.first->second; + storage_GetPropResponse.name_ref() = "storage.GetPropResponse"; + storage_GetPropResponse.is_union_ref() = false; + static const EncodedThriftField + storage_GetPropResponse_fields[] = { + std::make_tuple(1, "result", false, std::make_unique>("storage.ResponseCommon"), std::vector{}), + std::make_tuple(2, "props", true, std::make_unique>("common.DataSet"), std::vector{}), + }; + for (const auto& f : storage_GetPropResponse_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + storage_GetPropResponse.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::storage::cpp2::NewTag>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("storage.NewTag", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& storage_NewTag = res.first->second; + storage_NewTag.name_ref() = "storage.NewTag"; + storage_NewTag.is_union_ref() = false; + static const EncodedThriftField + storage_NewTag_fields[] = { + std::make_tuple(1, "tag_id", false, std::make_unique("common.TagID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + std::make_tuple(2, "props", false, std::make_unique(std::make_unique>("common.Value")), std::vector{}), + }; + for (const auto& f : storage_NewTag_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + storage_NewTag.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::storage::cpp2::NewVertex>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("storage.NewVertex", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& storage_NewVertex = res.first->second; + storage_NewVertex.name_ref() = "storage.NewVertex"; + storage_NewVertex.is_union_ref() = false; + static const EncodedThriftField + storage_NewVertex_fields[] = { + std::make_tuple(1, "id", false, std::make_unique>("common.Value"), std::vector{}), + std::make_tuple(2, "tags", false, std::make_unique(std::make_unique>("storage.NewTag")), std::vector{}), + }; + for (const auto& f : storage_NewVertex_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + storage_NewVertex.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::storage::cpp2::EdgeKey>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("storage.EdgeKey", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& storage_EdgeKey = res.first->second; + storage_EdgeKey.name_ref() = "storage.EdgeKey"; + storage_EdgeKey.is_union_ref() = false; + static const EncodedThriftField + storage_EdgeKey_fields[] = { + std::make_tuple(1, "src", false, std::make_unique>("common.Value"), std::vector{}), + std::make_tuple(2, "edge_type", false, std::make_unique("common.EdgeType", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + std::make_tuple(3, "ranking", false, std::make_unique("common.EdgeRanking", std::make_unique(ThriftPrimitiveType::THRIFT_I64_TYPE)), std::vector{}), + std::make_tuple(4, "dst", false, std::make_unique>("common.Value"), std::vector{}), + }; + for (const auto& f : storage_EdgeKey_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + storage_EdgeKey.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::storage::cpp2::NewEdge>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("storage.NewEdge", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& storage_NewEdge = res.first->second; + storage_NewEdge.name_ref() = "storage.NewEdge"; + storage_NewEdge.is_union_ref() = false; + static const EncodedThriftField + storage_NewEdge_fields[] = { + std::make_tuple(1, "key", false, std::make_unique>("storage.EdgeKey"), std::vector{}), + std::make_tuple(2, "props", false, std::make_unique(std::make_unique>("common.Value")), std::vector{}), + }; + for (const auto& f : storage_NewEdge_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + storage_NewEdge.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::storage::cpp2::AddVerticesRequest>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("storage.AddVerticesRequest", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& storage_AddVerticesRequest = res.first->second; + storage_AddVerticesRequest.name_ref() = "storage.AddVerticesRequest"; + storage_AddVerticesRequest.is_union_ref() = false; + static const EncodedThriftField + storage_AddVerticesRequest_fields[] = { + std::make_tuple(1, "space_id", false, std::make_unique("common.GraphSpaceID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + std::make_tuple(2, "parts", false, std::make_unique(std::make_unique("common.PartitionID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::make_unique(std::make_unique>("storage.NewVertex"))), std::vector{}), + std::make_tuple(3, "prop_names", false, std::make_unique(std::make_unique("common.TagID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::make_unique(std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE))), std::vector{}), + std::make_tuple(4, "if_not_exists", false, std::make_unique(ThriftPrimitiveType::THRIFT_BOOL_TYPE), std::vector{}), + std::make_tuple(5, "common", true, std::make_unique>("storage.RequestCommon"), std::vector{}), + }; + for (const auto& f : storage_AddVerticesRequest_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + storage_AddVerticesRequest.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::storage::cpp2::AddEdgesRequest>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("storage.AddEdgesRequest", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& storage_AddEdgesRequest = res.first->second; + storage_AddEdgesRequest.name_ref() = "storage.AddEdgesRequest"; + storage_AddEdgesRequest.is_union_ref() = false; + static const EncodedThriftField + storage_AddEdgesRequest_fields[] = { + std::make_tuple(1, "space_id", false, std::make_unique("common.GraphSpaceID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + std::make_tuple(2, "parts", false, std::make_unique(std::make_unique("common.PartitionID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::make_unique(std::make_unique>("storage.NewEdge"))), std::vector{}), + std::make_tuple(3, "prop_names", false, std::make_unique(std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE)), std::vector{}), + std::make_tuple(4, "if_not_exists", false, std::make_unique(ThriftPrimitiveType::THRIFT_BOOL_TYPE), std::vector{}), + std::make_tuple(5, "common", true, std::make_unique>("storage.RequestCommon"), std::vector{}), + }; + for (const auto& f : storage_AddEdgesRequest_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + storage_AddEdgesRequest.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::storage::cpp2::DeleteVerticesRequest>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("storage.DeleteVerticesRequest", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& storage_DeleteVerticesRequest = res.first->second; + storage_DeleteVerticesRequest.name_ref() = "storage.DeleteVerticesRequest"; + storage_DeleteVerticesRequest.is_union_ref() = false; + static const EncodedThriftField + storage_DeleteVerticesRequest_fields[] = { + std::make_tuple(1, "space_id", false, std::make_unique("common.GraphSpaceID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + std::make_tuple(2, "parts", false, std::make_unique(std::make_unique("common.PartitionID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::make_unique(std::make_unique>("common.Value"))), std::vector{}), + std::make_tuple(3, "common", true, std::make_unique>("storage.RequestCommon"), std::vector{}), + }; + for (const auto& f : storage_DeleteVerticesRequest_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + storage_DeleteVerticesRequest.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::storage::cpp2::DeleteEdgesRequest>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("storage.DeleteEdgesRequest", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& storage_DeleteEdgesRequest = res.first->second; + storage_DeleteEdgesRequest.name_ref() = "storage.DeleteEdgesRequest"; + storage_DeleteEdgesRequest.is_union_ref() = false; + static const EncodedThriftField + storage_DeleteEdgesRequest_fields[] = { + std::make_tuple(1, "space_id", false, std::make_unique("common.GraphSpaceID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + std::make_tuple(2, "parts", false, std::make_unique(std::make_unique("common.PartitionID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::make_unique(std::make_unique>("storage.EdgeKey"))), std::vector{}), + std::make_tuple(3, "common", true, std::make_unique>("storage.RequestCommon"), std::vector{}), + }; + for (const auto& f : storage_DeleteEdgesRequest_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + storage_DeleteEdgesRequest.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::storage::cpp2::DelTags>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("storage.DelTags", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& storage_DelTags = res.first->second; + storage_DelTags.name_ref() = "storage.DelTags"; + storage_DelTags.is_union_ref() = false; + static const EncodedThriftField + storage_DelTags_fields[] = { + std::make_tuple(1, "id", false, std::make_unique>("common.Value"), std::vector{}), + std::make_tuple(2, "tags", false, std::make_unique(std::make_unique("common.TagID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE))), std::vector{}), + }; + for (const auto& f : storage_DelTags_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + storage_DelTags.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::storage::cpp2::DeleteTagsRequest>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("storage.DeleteTagsRequest", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& storage_DeleteTagsRequest = res.first->second; + storage_DeleteTagsRequest.name_ref() = "storage.DeleteTagsRequest"; + storage_DeleteTagsRequest.is_union_ref() = false; + static const EncodedThriftField + storage_DeleteTagsRequest_fields[] = { + std::make_tuple(1, "space_id", false, std::make_unique("common.GraphSpaceID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + std::make_tuple(2, "parts", false, std::make_unique(std::make_unique("common.PartitionID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::make_unique(std::make_unique>("storage.DelTags"))), std::vector{}), + std::make_tuple(3, "common", true, std::make_unique>("storage.RequestCommon"), std::vector{}), + }; + for (const auto& f : storage_DeleteTagsRequest_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + storage_DeleteTagsRequest.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::storage::cpp2::UpdateResponse>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("storage.UpdateResponse", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& storage_UpdateResponse = res.first->second; + storage_UpdateResponse.name_ref() = "storage.UpdateResponse"; + storage_UpdateResponse.is_union_ref() = false; + static const EncodedThriftField + storage_UpdateResponse_fields[] = { + std::make_tuple(1, "result", false, std::make_unique>("storage.ResponseCommon"), std::vector{}), + std::make_tuple(2, "props", true, std::make_unique>("common.DataSet"), std::vector{}), + }; + for (const auto& f : storage_UpdateResponse_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + storage_UpdateResponse.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::storage::cpp2::UpdatedProp>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("storage.UpdatedProp", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& storage_UpdatedProp = res.first->second; + storage_UpdatedProp.name_ref() = "storage.UpdatedProp"; + storage_UpdatedProp.is_union_ref() = false; + static const EncodedThriftField + storage_UpdatedProp_fields[] = { + std::make_tuple(1, "name", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + std::make_tuple(2, "value", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + }; + for (const auto& f : storage_UpdatedProp_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + storage_UpdatedProp.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::storage::cpp2::UpdateVertexRequest>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("storage.UpdateVertexRequest", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& storage_UpdateVertexRequest = res.first->second; + storage_UpdateVertexRequest.name_ref() = "storage.UpdateVertexRequest"; + storage_UpdateVertexRequest.is_union_ref() = false; + static const EncodedThriftField + storage_UpdateVertexRequest_fields[] = { + std::make_tuple(1, "space_id", false, std::make_unique("common.GraphSpaceID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + std::make_tuple(2, "part_id", false, std::make_unique("common.PartitionID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + std::make_tuple(3, "vertex_id", false, std::make_unique>("common.Value"), std::vector{}), + std::make_tuple(4, "tag_id", false, std::make_unique("common.TagID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + std::make_tuple(5, "updated_props", false, std::make_unique(std::make_unique>("storage.UpdatedProp")), std::vector{}), + std::make_tuple(6, "insertable", true, std::make_unique(ThriftPrimitiveType::THRIFT_BOOL_TYPE), std::vector{}), + std::make_tuple(7, "return_props", true, std::make_unique(std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE)), std::vector{}), + std::make_tuple(8, "condition", true, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + std::make_tuple(9, "common", true, std::make_unique>("storage.RequestCommon"), std::vector{}), + }; + for (const auto& f : storage_UpdateVertexRequest_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + storage_UpdateVertexRequest.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::storage::cpp2::UpdateEdgeRequest>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("storage.UpdateEdgeRequest", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& storage_UpdateEdgeRequest = res.first->second; + storage_UpdateEdgeRequest.name_ref() = "storage.UpdateEdgeRequest"; + storage_UpdateEdgeRequest.is_union_ref() = false; + static const EncodedThriftField + storage_UpdateEdgeRequest_fields[] = { + std::make_tuple(1, "space_id", false, std::make_unique("common.GraphSpaceID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + std::make_tuple(2, "part_id", false, std::make_unique("common.PartitionID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + std::make_tuple(3, "edge_key", false, std::make_unique>("storage.EdgeKey"), std::vector{}), + std::make_tuple(4, "updated_props", false, std::make_unique(std::make_unique>("storage.UpdatedProp")), std::vector{}), + std::make_tuple(5, "insertable", true, std::make_unique(ThriftPrimitiveType::THRIFT_BOOL_TYPE), std::vector{}), + std::make_tuple(6, "return_props", true, std::make_unique(std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE)), std::vector{}), + std::make_tuple(7, "condition", true, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + std::make_tuple(8, "common", true, std::make_unique>("storage.RequestCommon"), std::vector{}), + }; + for (const auto& f : storage_UpdateEdgeRequest_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + storage_UpdateEdgeRequest.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::storage::cpp2::GetUUIDReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("storage.GetUUIDReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& storage_GetUUIDReq = res.first->second; + storage_GetUUIDReq.name_ref() = "storage.GetUUIDReq"; + storage_GetUUIDReq.is_union_ref() = false; + static const EncodedThriftField + storage_GetUUIDReq_fields[] = { + std::make_tuple(1, "space_id", false, std::make_unique("common.GraphSpaceID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + std::make_tuple(2, "part_id", false, std::make_unique("common.PartitionID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + std::make_tuple(3, "name", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + std::make_tuple(4, "common", true, std::make_unique>("storage.RequestCommon"), std::vector{}), + }; + for (const auto& f : storage_GetUUIDReq_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + storage_GetUUIDReq.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::storage::cpp2::GetUUIDResp>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("storage.GetUUIDResp", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& storage_GetUUIDResp = res.first->second; + storage_GetUUIDResp.name_ref() = "storage.GetUUIDResp"; + storage_GetUUIDResp.is_union_ref() = false; + static const EncodedThriftField + storage_GetUUIDResp_fields[] = { + std::make_tuple(1, "result", false, std::make_unique>("storage.ResponseCommon"), std::vector{}), + std::make_tuple(2, "id", false, std::make_unique>("common.Value"), std::vector{}), + }; + for (const auto& f : storage_GetUUIDResp_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + storage_GetUUIDResp.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::storage::cpp2::LookupIndexResp>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("storage.LookupIndexResp", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& storage_LookupIndexResp = res.first->second; + storage_LookupIndexResp.name_ref() = "storage.LookupIndexResp"; + storage_LookupIndexResp.is_union_ref() = false; + static const EncodedThriftField + storage_LookupIndexResp_fields[] = { + std::make_tuple(1, "result", false, std::make_unique>("storage.ResponseCommon"), std::vector{}), + std::make_tuple(2, "data", true, std::make_unique>("common.DataSet"), std::vector{}), + }; + for (const auto& f : storage_LookupIndexResp_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + storage_LookupIndexResp.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::storage::cpp2::IndexColumnHint>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("storage.IndexColumnHint", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& storage_IndexColumnHint = res.first->second; + storage_IndexColumnHint.name_ref() = "storage.IndexColumnHint"; + storage_IndexColumnHint.is_union_ref() = false; + static const EncodedThriftField + storage_IndexColumnHint_fields[] = { + std::make_tuple(1, "column_name", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + std::make_tuple(2, "scan_type", false, std::make_unique>("storage.ScanType"), std::vector{}), + std::make_tuple(3, "begin_value", false, std::make_unique>("common.Value"), std::vector{}), + std::make_tuple(4, "end_value", false, std::make_unique>("common.Value"), std::vector{}), + }; + for (const auto& f : storage_IndexColumnHint_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + storage_IndexColumnHint.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::storage::cpp2::IndexQueryContext>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("storage.IndexQueryContext", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& storage_IndexQueryContext = res.first->second; + storage_IndexQueryContext.name_ref() = "storage.IndexQueryContext"; + storage_IndexQueryContext.is_union_ref() = false; + static const EncodedThriftField + storage_IndexQueryContext_fields[] = { + std::make_tuple(1, "index_id", false, std::make_unique("common.IndexID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + std::make_tuple(2, "filter", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + std::make_tuple(3, "column_hints", false, std::make_unique(std::make_unique>("storage.IndexColumnHint")), std::vector{}), + }; + for (const auto& f : storage_IndexQueryContext_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + storage_IndexQueryContext.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::storage::cpp2::IndexSpec>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("storage.IndexSpec", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& storage_IndexSpec = res.first->second; + storage_IndexSpec.name_ref() = "storage.IndexSpec"; + storage_IndexSpec.is_union_ref() = false; + static const EncodedThriftField + storage_IndexSpec_fields[] = { + std::make_tuple(1, "contexts", false, std::make_unique(std::make_unique>("storage.IndexQueryContext")), std::vector{}), + std::make_tuple(2, "schema_id", false, std::make_unique>("common.SchemaID"), std::vector{}), + }; + for (const auto& f : storage_IndexSpec_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + storage_IndexSpec.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::storage::cpp2::LookupIndexRequest>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("storage.LookupIndexRequest", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& storage_LookupIndexRequest = res.first->second; + storage_LookupIndexRequest.name_ref() = "storage.LookupIndexRequest"; + storage_LookupIndexRequest.is_union_ref() = false; + static const EncodedThriftField + storage_LookupIndexRequest_fields[] = { + std::make_tuple(1, "space_id", false, std::make_unique("common.GraphSpaceID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + std::make_tuple(2, "parts", false, std::make_unique(std::make_unique("common.PartitionID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE))), std::vector{}), + std::make_tuple(3, "indices", false, std::make_unique>("storage.IndexSpec"), std::vector{}), + std::make_tuple(4, "return_columns", true, std::make_unique(std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE)), std::vector{}), + std::make_tuple(5, "common", true, std::make_unique>("storage.RequestCommon"), std::vector{}), + std::make_tuple(6, "limit", true, std::make_unique(ThriftPrimitiveType::THRIFT_I64_TYPE), std::vector{}), + }; + for (const auto& f : storage_LookupIndexRequest_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + storage_LookupIndexRequest.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::storage::cpp2::LookupAndTraverseRequest>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("storage.LookupAndTraverseRequest", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& storage_LookupAndTraverseRequest = res.first->second; + storage_LookupAndTraverseRequest.name_ref() = "storage.LookupAndTraverseRequest"; + storage_LookupAndTraverseRequest.is_union_ref() = false; + static const EncodedThriftField + storage_LookupAndTraverseRequest_fields[] = { + std::make_tuple(1, "space_id", false, std::make_unique("common.GraphSpaceID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + std::make_tuple(2, "parts", false, std::make_unique(std::make_unique("common.PartitionID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE))), std::vector{}), + std::make_tuple(3, "indices", false, std::make_unique>("storage.IndexSpec"), std::vector{}), + std::make_tuple(4, "traverse_spec", false, std::make_unique>("storage.TraverseSpec"), std::vector{}), + std::make_tuple(5, "common", true, std::make_unique>("storage.RequestCommon"), std::vector{}), + }; + for (const auto& f : storage_LookupAndTraverseRequest_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + storage_LookupAndTraverseRequest.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::storage::cpp2::ScanVertexRequest>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("storage.ScanVertexRequest", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& storage_ScanVertexRequest = res.first->second; + storage_ScanVertexRequest.name_ref() = "storage.ScanVertexRequest"; + storage_ScanVertexRequest.is_union_ref() = false; + static const EncodedThriftField + storage_ScanVertexRequest_fields[] = { + std::make_tuple(1, "space_id", false, std::make_unique("common.GraphSpaceID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + std::make_tuple(2, "part_id", false, std::make_unique("common.PartitionID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + std::make_tuple(3, "cursor", true, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + std::make_tuple(4, "return_columns", false, std::make_unique>("storage.VertexProp"), std::vector{}), + std::make_tuple(5, "limit", false, std::make_unique(ThriftPrimitiveType::THRIFT_I64_TYPE), std::vector{}), + std::make_tuple(6, "start_time", true, std::make_unique(ThriftPrimitiveType::THRIFT_I64_TYPE), std::vector{}), + std::make_tuple(7, "end_time", true, std::make_unique(ThriftPrimitiveType::THRIFT_I64_TYPE), std::vector{}), + std::make_tuple(8, "filter", true, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + std::make_tuple(9, "only_latest_version", false, std::make_unique(ThriftPrimitiveType::THRIFT_BOOL_TYPE), std::vector{}), + std::make_tuple(10, "enable_read_from_follower", false, std::make_unique(ThriftPrimitiveType::THRIFT_BOOL_TYPE), std::vector{}), + std::make_tuple(11, "common", true, std::make_unique>("storage.RequestCommon"), std::vector{}), + }; + for (const auto& f : storage_ScanVertexRequest_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + storage_ScanVertexRequest.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::storage::cpp2::ScanVertexResponse>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("storage.ScanVertexResponse", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& storage_ScanVertexResponse = res.first->second; + storage_ScanVertexResponse.name_ref() = "storage.ScanVertexResponse"; + storage_ScanVertexResponse.is_union_ref() = false; + static const EncodedThriftField + storage_ScanVertexResponse_fields[] = { + std::make_tuple(1, "result", false, std::make_unique>("storage.ResponseCommon"), std::vector{}), + std::make_tuple(2, "vertex_data", false, std::make_unique>("common.DataSet"), std::vector{}), + std::make_tuple(3, "has_next", false, std::make_unique(ThriftPrimitiveType::THRIFT_BOOL_TYPE), std::vector{}), + std::make_tuple(4, "next_cursor", true, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + }; + for (const auto& f : storage_ScanVertexResponse_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + storage_ScanVertexResponse.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::storage::cpp2::ScanEdgeRequest>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("storage.ScanEdgeRequest", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& storage_ScanEdgeRequest = res.first->second; + storage_ScanEdgeRequest.name_ref() = "storage.ScanEdgeRequest"; + storage_ScanEdgeRequest.is_union_ref() = false; + static const EncodedThriftField + storage_ScanEdgeRequest_fields[] = { + std::make_tuple(1, "space_id", false, std::make_unique("common.GraphSpaceID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + std::make_tuple(2, "part_id", false, std::make_unique("common.PartitionID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + std::make_tuple(3, "cursor", true, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + std::make_tuple(4, "return_columns", false, std::make_unique>("storage.EdgeProp"), std::vector{}), + std::make_tuple(5, "limit", false, std::make_unique(ThriftPrimitiveType::THRIFT_I64_TYPE), std::vector{}), + std::make_tuple(6, "start_time", true, std::make_unique(ThriftPrimitiveType::THRIFT_I64_TYPE), std::vector{}), + std::make_tuple(7, "end_time", true, std::make_unique(ThriftPrimitiveType::THRIFT_I64_TYPE), std::vector{}), + std::make_tuple(8, "filter", true, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + std::make_tuple(9, "only_latest_version", false, std::make_unique(ThriftPrimitiveType::THRIFT_BOOL_TYPE), std::vector{}), + std::make_tuple(10, "enable_read_from_follower", false, std::make_unique(ThriftPrimitiveType::THRIFT_BOOL_TYPE), std::vector{}), + std::make_tuple(11, "common", true, std::make_unique>("storage.RequestCommon"), std::vector{}), + }; + for (const auto& f : storage_ScanEdgeRequest_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + storage_ScanEdgeRequest.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::storage::cpp2::ScanEdgeResponse>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("storage.ScanEdgeResponse", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& storage_ScanEdgeResponse = res.first->second; + storage_ScanEdgeResponse.name_ref() = "storage.ScanEdgeResponse"; + storage_ScanEdgeResponse.is_union_ref() = false; + static const EncodedThriftField + storage_ScanEdgeResponse_fields[] = { + std::make_tuple(1, "result", false, std::make_unique>("storage.ResponseCommon"), std::vector{}), + std::make_tuple(2, "edge_data", false, std::make_unique>("common.DataSet"), std::vector{}), + std::make_tuple(3, "has_next", false, std::make_unique(ThriftPrimitiveType::THRIFT_BOOL_TYPE), std::vector{}), + std::make_tuple(4, "next_cursor", true, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + }; + for (const auto& f : storage_ScanEdgeResponse_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + storage_ScanEdgeResponse.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::storage::cpp2::TaskPara>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("storage.TaskPara", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& storage_TaskPara = res.first->second; + storage_TaskPara.name_ref() = "storage.TaskPara"; + storage_TaskPara.is_union_ref() = false; + static const EncodedThriftField + storage_TaskPara_fields[] = { + std::make_tuple(1, "space_id", false, std::make_unique("common.GraphSpaceID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + std::make_tuple(2, "parts", true, std::make_unique(std::make_unique("common.PartitionID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE))), std::vector{}), + std::make_tuple(3, "task_specfic_paras", true, std::make_unique(std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE)), std::vector{}), + }; + for (const auto& f : storage_TaskPara_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + storage_TaskPara.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::storage::cpp2::AddAdminTaskRequest>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("storage.AddAdminTaskRequest", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& storage_AddAdminTaskRequest = res.first->second; + storage_AddAdminTaskRequest.name_ref() = "storage.AddAdminTaskRequest"; + storage_AddAdminTaskRequest.is_union_ref() = false; + static const EncodedThriftField + storage_AddAdminTaskRequest_fields[] = { + std::make_tuple(1, "cmd", false, std::make_unique>("meta.AdminCmd"), std::vector{}), + std::make_tuple(2, "job_id", false, std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE), std::vector{}), + std::make_tuple(3, "task_id", false, std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE), std::vector{}), + std::make_tuple(4, "para", false, std::make_unique>("storage.TaskPara"), std::vector{}), + std::make_tuple(5, "concurrency", true, std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE), std::vector{}), + }; + for (const auto& f : storage_AddAdminTaskRequest_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + storage_AddAdminTaskRequest.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::storage::cpp2::StopAdminTaskRequest>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("storage.StopAdminTaskRequest", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& storage_StopAdminTaskRequest = res.first->second; + storage_StopAdminTaskRequest.name_ref() = "storage.StopAdminTaskRequest"; + storage_StopAdminTaskRequest.is_union_ref() = false; + static const EncodedThriftField + storage_StopAdminTaskRequest_fields[] = { + std::make_tuple(1, "job_id", false, std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE), std::vector{}), + std::make_tuple(2, "task_id", false, std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE), std::vector{}), + }; + for (const auto& f : storage_StopAdminTaskRequest_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + storage_StopAdminTaskRequest.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::storage::cpp2::AdminExecResp>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("storage.AdminExecResp", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& storage_AdminExecResp = res.first->second; + storage_AdminExecResp.name_ref() = "storage.AdminExecResp"; + storage_AdminExecResp.is_union_ref() = false; + static const EncodedThriftField + storage_AdminExecResp_fields[] = { + std::make_tuple(1, "result", false, std::make_unique>("storage.ResponseCommon"), std::vector{}), + std::make_tuple(2, "stats", true, std::make_unique>("meta.StatsItem"), std::vector{}), + }; + for (const auto& f : storage_AdminExecResp_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + storage_AdminExecResp.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::storage::cpp2::TransLeaderReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("storage.TransLeaderReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& storage_TransLeaderReq = res.first->second; + storage_TransLeaderReq.name_ref() = "storage.TransLeaderReq"; + storage_TransLeaderReq.is_union_ref() = false; + static const EncodedThriftField + storage_TransLeaderReq_fields[] = { + std::make_tuple(1, "space_id", false, std::make_unique("common.GraphSpaceID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + std::make_tuple(2, "part_id", false, std::make_unique("common.PartitionID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + std::make_tuple(3, "new_leader", false, std::make_unique>("common.HostAddr"), std::vector{}), + }; + for (const auto& f : storage_TransLeaderReq_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + storage_TransLeaderReq.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::storage::cpp2::AddPartReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("storage.AddPartReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& storage_AddPartReq = res.first->second; + storage_AddPartReq.name_ref() = "storage.AddPartReq"; + storage_AddPartReq.is_union_ref() = false; + static const EncodedThriftField + storage_AddPartReq_fields[] = { + std::make_tuple(1, "space_id", false, std::make_unique("common.GraphSpaceID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + std::make_tuple(2, "part_id", false, std::make_unique("common.PartitionID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + std::make_tuple(3, "as_learner", false, std::make_unique(ThriftPrimitiveType::THRIFT_BOOL_TYPE), std::vector{}), + std::make_tuple(4, "peers", false, std::make_unique(std::make_unique>("common.HostAddr")), std::vector{}), + }; + for (const auto& f : storage_AddPartReq_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + storage_AddPartReq.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::storage::cpp2::AddLearnerReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("storage.AddLearnerReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& storage_AddLearnerReq = res.first->second; + storage_AddLearnerReq.name_ref() = "storage.AddLearnerReq"; + storage_AddLearnerReq.is_union_ref() = false; + static const EncodedThriftField + storage_AddLearnerReq_fields[] = { + std::make_tuple(1, "space_id", false, std::make_unique("common.GraphSpaceID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + std::make_tuple(2, "part_id", false, std::make_unique("common.PartitionID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + std::make_tuple(3, "learner", false, std::make_unique>("common.HostAddr"), std::vector{}), + }; + for (const auto& f : storage_AddLearnerReq_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + storage_AddLearnerReq.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::storage::cpp2::RemovePartReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("storage.RemovePartReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& storage_RemovePartReq = res.first->second; + storage_RemovePartReq.name_ref() = "storage.RemovePartReq"; + storage_RemovePartReq.is_union_ref() = false; + static const EncodedThriftField + storage_RemovePartReq_fields[] = { + std::make_tuple(1, "space_id", false, std::make_unique("common.GraphSpaceID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + std::make_tuple(2, "part_id", false, std::make_unique("common.PartitionID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + }; + for (const auto& f : storage_RemovePartReq_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + storage_RemovePartReq.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::storage::cpp2::MemberChangeReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("storage.MemberChangeReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& storage_MemberChangeReq = res.first->second; + storage_MemberChangeReq.name_ref() = "storage.MemberChangeReq"; + storage_MemberChangeReq.is_union_ref() = false; + static const EncodedThriftField + storage_MemberChangeReq_fields[] = { + std::make_tuple(1, "space_id", false, std::make_unique("common.GraphSpaceID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + std::make_tuple(2, "part_id", false, std::make_unique("common.PartitionID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + std::make_tuple(3, "peer", false, std::make_unique>("common.HostAddr"), std::vector{}), + std::make_tuple(4, "add", false, std::make_unique(ThriftPrimitiveType::THRIFT_BOOL_TYPE), std::vector{}), + }; + for (const auto& f : storage_MemberChangeReq_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + storage_MemberChangeReq.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::storage::cpp2::CatchUpDataReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("storage.CatchUpDataReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& storage_CatchUpDataReq = res.first->second; + storage_CatchUpDataReq.name_ref() = "storage.CatchUpDataReq"; + storage_CatchUpDataReq.is_union_ref() = false; + static const EncodedThriftField + storage_CatchUpDataReq_fields[] = { + std::make_tuple(1, "space_id", false, std::make_unique("common.GraphSpaceID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + std::make_tuple(2, "part_id", false, std::make_unique("common.PartitionID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + std::make_tuple(3, "target", false, std::make_unique>("common.HostAddr"), std::vector{}), + }; + for (const auto& f : storage_CatchUpDataReq_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + storage_CatchUpDataReq.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::storage::cpp2::GetLeaderReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("storage.GetLeaderReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& storage_GetLeaderReq = res.first->second; + storage_GetLeaderReq.name_ref() = "storage.GetLeaderReq"; + storage_GetLeaderReq.is_union_ref() = false; + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::storage::cpp2::CreateCPRequest>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("storage.CreateCPRequest", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& storage_CreateCPRequest = res.first->second; + storage_CreateCPRequest.name_ref() = "storage.CreateCPRequest"; + storage_CreateCPRequest.is_union_ref() = false; + static const EncodedThriftField + storage_CreateCPRequest_fields[] = { + std::make_tuple(1, "space_id", false, std::make_unique("common.GraphSpaceID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + std::make_tuple(2, "name", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + }; + for (const auto& f : storage_CreateCPRequest_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + storage_CreateCPRequest.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::storage::cpp2::DropCPRequest>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("storage.DropCPRequest", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& storage_DropCPRequest = res.first->second; + storage_DropCPRequest.name_ref() = "storage.DropCPRequest"; + storage_DropCPRequest.is_union_ref() = false; + static const EncodedThriftField + storage_DropCPRequest_fields[] = { + std::make_tuple(1, "space_id", false, std::make_unique("common.GraphSpaceID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + std::make_tuple(2, "name", false, std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::vector{}), + }; + for (const auto& f : storage_DropCPRequest_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + storage_DropCPRequest.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::storage::cpp2::BlockingSignRequest>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("storage.BlockingSignRequest", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& storage_BlockingSignRequest = res.first->second; + storage_BlockingSignRequest.name_ref() = "storage.BlockingSignRequest"; + storage_BlockingSignRequest.is_union_ref() = false; + static const EncodedThriftField + storage_BlockingSignRequest_fields[] = { + std::make_tuple(1, "space_id", false, std::make_unique("common.GraphSpaceID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + std::make_tuple(2, "sign", false, std::make_unique>("storage.EngineSignType"), std::vector{}), + }; + for (const auto& f : storage_BlockingSignRequest_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + storage_BlockingSignRequest.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::storage::cpp2::GetLeaderPartsResp>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("storage.GetLeaderPartsResp", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& storage_GetLeaderPartsResp = res.first->second; + storage_GetLeaderPartsResp.name_ref() = "storage.GetLeaderPartsResp"; + storage_GetLeaderPartsResp.is_union_ref() = false; + static const EncodedThriftField + storage_GetLeaderPartsResp_fields[] = { + std::make_tuple(1, "result", false, std::make_unique>("storage.ResponseCommon"), std::vector{}), + std::make_tuple(2, "leader_parts", false, std::make_unique(std::make_unique("common.GraphSpaceID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::make_unique(std::make_unique("common.PartitionID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)))), std::vector{}), + }; + for (const auto& f : storage_GetLeaderPartsResp_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + storage_GetLeaderPartsResp.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::storage::cpp2::CheckPeersReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("storage.CheckPeersReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& storage_CheckPeersReq = res.first->second; + storage_CheckPeersReq.name_ref() = "storage.CheckPeersReq"; + storage_CheckPeersReq.is_union_ref() = false; + static const EncodedThriftField + storage_CheckPeersReq_fields[] = { + std::make_tuple(1, "space_id", false, std::make_unique("common.GraphSpaceID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + std::make_tuple(2, "part_id", false, std::make_unique("common.PartitionID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + std::make_tuple(3, "peers", false, std::make_unique(std::make_unique>("common.HostAddr")), std::vector{}), + }; + for (const auto& f : storage_CheckPeersReq_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + storage_CheckPeersReq.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::storage::cpp2::RebuildIndexRequest>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("storage.RebuildIndexRequest", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& storage_RebuildIndexRequest = res.first->second; + storage_RebuildIndexRequest.name_ref() = "storage.RebuildIndexRequest"; + storage_RebuildIndexRequest.is_union_ref() = false; + static const EncodedThriftField + storage_RebuildIndexRequest_fields[] = { + std::make_tuple(1, "space_id", false, std::make_unique("common.GraphSpaceID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + std::make_tuple(2, "parts", false, std::make_unique(std::make_unique("common.PartitionID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE))), std::vector{}), + std::make_tuple(3, "index_id", false, std::make_unique("common.IndexID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + }; + for (const auto& f : storage_RebuildIndexRequest_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + storage_RebuildIndexRequest.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::storage::cpp2::CreateCPResp>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("storage.CreateCPResp", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& storage_CreateCPResp = res.first->second; + storage_CreateCPResp.name_ref() = "storage.CreateCPResp"; + storage_CreateCPResp.is_union_ref() = false; + static const EncodedThriftField + storage_CreateCPResp_fields[] = { + std::make_tuple(1, "result", false, std::make_unique>("storage.ResponseCommon"), std::vector{}), + std::make_tuple(2, "info", false, std::make_unique(std::make_unique>("common.CheckpointInfo")), std::vector{}), + }; + for (const auto& f : storage_CreateCPResp_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + storage_CreateCPResp.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::storage::cpp2::ListClusterInfoResp>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("storage.ListClusterInfoResp", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& storage_ListClusterInfoResp = res.first->second; + storage_ListClusterInfoResp.name_ref() = "storage.ListClusterInfoResp"; + storage_ListClusterInfoResp.is_union_ref() = false; + static const EncodedThriftField + storage_ListClusterInfoResp_fields[] = { + std::make_tuple(1, "result", false, std::make_unique>("storage.ResponseCommon"), std::vector{}), + std::make_tuple(2, "dir", false, std::make_unique>("common.DirInfo"), std::vector{}), + }; + for (const auto& f : storage_ListClusterInfoResp_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + storage_ListClusterInfoResp.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::storage::cpp2::ListClusterInfoReq>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("storage.ListClusterInfoReq", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& storage_ListClusterInfoReq = res.first->second; + storage_ListClusterInfoReq.name_ref() = "storage.ListClusterInfoReq"; + storage_ListClusterInfoReq.is_union_ref() = false; + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::storage::cpp2::KVGetRequest>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("storage.KVGetRequest", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& storage_KVGetRequest = res.first->second; + storage_KVGetRequest.name_ref() = "storage.KVGetRequest"; + storage_KVGetRequest.is_union_ref() = false; + static const EncodedThriftField + storage_KVGetRequest_fields[] = { + std::make_tuple(1, "space_id", false, std::make_unique("common.GraphSpaceID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + std::make_tuple(2, "parts", false, std::make_unique(std::make_unique("common.PartitionID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::make_unique(std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE))), std::vector{}), + std::make_tuple(3, "return_partly", false, std::make_unique(ThriftPrimitiveType::THRIFT_BOOL_TYPE), std::vector{}), + }; + for (const auto& f : storage_KVGetRequest_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + storage_KVGetRequest.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::storage::cpp2::KVGetResponse>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("storage.KVGetResponse", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& storage_KVGetResponse = res.first->second; + storage_KVGetResponse.name_ref() = "storage.KVGetResponse"; + storage_KVGetResponse.is_union_ref() = false; + static const EncodedThriftField + storage_KVGetResponse_fields[] = { + std::make_tuple(1, "result", false, std::make_unique>("storage.ResponseCommon"), std::vector{}), + std::make_tuple(2, "key_values", false, std::make_unique(std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE), std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE)), std::vector{}), + }; + for (const auto& f : storage_KVGetResponse_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + storage_KVGetResponse.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::storage::cpp2::KVPutRequest>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("storage.KVPutRequest", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& storage_KVPutRequest = res.first->second; + storage_KVPutRequest.name_ref() = "storage.KVPutRequest"; + storage_KVPutRequest.is_union_ref() = false; + static const EncodedThriftField + storage_KVPutRequest_fields[] = { + std::make_tuple(1, "space_id", false, std::make_unique("common.GraphSpaceID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + std::make_tuple(2, "parts", false, std::make_unique(std::make_unique("common.PartitionID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::make_unique(std::make_unique>("common.KeyValue"))), std::vector{}), + }; + for (const auto& f : storage_KVPutRequest_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + storage_KVPutRequest.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::storage::cpp2::KVRemoveRequest>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("storage.KVRemoveRequest", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& storage_KVRemoveRequest = res.first->second; + storage_KVRemoveRequest.name_ref() = "storage.KVRemoveRequest"; + storage_KVRemoveRequest.is_union_ref() = false; + static const EncodedThriftField + storage_KVRemoveRequest_fields[] = { + std::make_tuple(1, "space_id", false, std::make_unique("common.GraphSpaceID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + std::make_tuple(2, "parts", false, std::make_unique(std::make_unique("common.PartitionID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::make_unique(std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE))), std::vector{}), + }; + for (const auto& f : storage_KVRemoveRequest_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + storage_KVRemoveRequest.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::storage::cpp2::InternalTxnRequest>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("storage.InternalTxnRequest", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& storage_InternalTxnRequest = res.first->second; + storage_InternalTxnRequest.name_ref() = "storage.InternalTxnRequest"; + storage_InternalTxnRequest.is_union_ref() = false; + static const EncodedThriftField + storage_InternalTxnRequest_fields[] = { + std::make_tuple(1, "txn_id", false, std::make_unique(ThriftPrimitiveType::THRIFT_I64_TYPE), std::vector{}), + std::make_tuple(2, "term_of_parts", false, std::make_unique(std::make_unique("common.PartitionID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::make_unique(ThriftPrimitiveType::THRIFT_I64_TYPE)), std::vector{}), + std::make_tuple(3, "add_edge_req", true, std::make_unique>("storage.AddEdgesRequest"), std::vector{}), + std::make_tuple(4, "upd_edge_req", true, std::make_unique>("storage.UpdateEdgeRequest"), std::vector{}), + std::make_tuple(5, "edge_ver", true, std::make_unique(std::make_unique("common.PartitionID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::make_unique(std::make_unique(ThriftPrimitiveType::THRIFT_I64_TYPE))), std::vector{}), + }; + for (const auto& f : storage_InternalTxnRequest_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + storage_InternalTxnRequest.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::storage::cpp2::ChainAddEdgesRequest>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("storage.ChainAddEdgesRequest", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& storage_ChainAddEdgesRequest = res.first->second; + storage_ChainAddEdgesRequest.name_ref() = "storage.ChainAddEdgesRequest"; + storage_ChainAddEdgesRequest.is_union_ref() = false; + static const EncodedThriftField + storage_ChainAddEdgesRequest_fields[] = { + std::make_tuple(1, "space_id", false, std::make_unique("common.GraphSpaceID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + std::make_tuple(2, "parts", false, std::make_unique(std::make_unique("common.PartitionID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::make_unique(std::make_unique>("storage.NewEdge"))), std::vector{}), + std::make_tuple(3, "prop_names", false, std::make_unique(std::make_unique(ThriftPrimitiveType::THRIFT_BINARY_TYPE)), std::vector{}), + std::make_tuple(4, "if_not_exists", false, std::make_unique(ThriftPrimitiveType::THRIFT_BOOL_TYPE), std::vector{}), + std::make_tuple(5, "term", false, std::make_unique(ThriftPrimitiveType::THRIFT_I64_TYPE), std::vector{}), + std::make_tuple(6, "edge_version", true, std::make_unique(ThriftPrimitiveType::THRIFT_I64_TYPE), std::vector{}), + }; + for (const auto& f : storage_ChainAddEdgesRequest_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + storage_ChainAddEdgesRequest.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} +const ::apache::thrift::metadata::ThriftStruct& +StructMetadata<::nebula::storage::cpp2::ChainUpdateEdgeRequest>::gen(ThriftMetadata& metadata) { + auto res = metadata.structs_ref()->emplace("storage.ChainUpdateEdgeRequest", ::apache::thrift::metadata::ThriftStruct{}); + if (!res.second) { + return res.first->second; + } + ::apache::thrift::metadata::ThriftStruct& storage_ChainUpdateEdgeRequest = res.first->second; + storage_ChainUpdateEdgeRequest.name_ref() = "storage.ChainUpdateEdgeRequest"; + storage_ChainUpdateEdgeRequest.is_union_ref() = false; + static const EncodedThriftField + storage_ChainUpdateEdgeRequest_fields[] = { + std::make_tuple(1, "update_edge_request", false, std::make_unique>("storage.UpdateEdgeRequest"), std::vector{}), + std::make_tuple(2, "term", false, std::make_unique(ThriftPrimitiveType::THRIFT_I64_TYPE), std::vector{}), + std::make_tuple(3, "edge_version", true, std::make_unique(ThriftPrimitiveType::THRIFT_I64_TYPE), std::vector{}), + std::make_tuple(4, "space_id", false, std::make_unique("common.GraphSpaceID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE)), std::vector{}), + std::make_tuple(5, "parts", false, std::make_unique(std::make_unique("common.PartitionID", std::make_unique(ThriftPrimitiveType::THRIFT_I32_TYPE))), std::vector{}), + }; + for (const auto& f : storage_ChainUpdateEdgeRequest_fields) { + ::apache::thrift::metadata::ThriftField field; + field.id_ref() = std::get<0>(f); + field.name_ref() = std::get<1>(f); + field.is_optional_ref() = std::get<2>(f); + std::get<3>(f)->writeAndGenType(*field.type_ref(), metadata); + field.structured_annotations_ref() = std::get<4>(f); + storage_ChainUpdateEdgeRequest.fields_ref()->push_back(std::move(field)); + } + return res.first->second; +} + +void ServiceMetadata<::nebula::storage::cpp2::GraphStorageServiceSvIf>::gen_getNeighbors(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "getNeighbors"; + auto func_ret_type = std::make_unique>("storage.GetNeighborsResponse"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField storage_GraphStorageService_getNeighbors_req_1; + storage_GraphStorageService_getNeighbors_req_1.id_ref() = 1; + storage_GraphStorageService_getNeighbors_req_1.name_ref() = "req"; + storage_GraphStorageService_getNeighbors_req_1.is_optional_ref() = false; + auto storage_GraphStorageService_getNeighbors_req_1_type = std::make_unique>("storage.GetNeighborsRequest"); + storage_GraphStorageService_getNeighbors_req_1_type->writeAndGenType(*storage_GraphStorageService_getNeighbors_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(storage_GraphStorageService_getNeighbors_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::storage::cpp2::GraphStorageServiceSvIf>::gen_getProps(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "getProps"; + auto func_ret_type = std::make_unique>("storage.GetPropResponse"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField storage_GraphStorageService_getProps_req_1; + storage_GraphStorageService_getProps_req_1.id_ref() = 1; + storage_GraphStorageService_getProps_req_1.name_ref() = "req"; + storage_GraphStorageService_getProps_req_1.is_optional_ref() = false; + auto storage_GraphStorageService_getProps_req_1_type = std::make_unique>("storage.GetPropRequest"); + storage_GraphStorageService_getProps_req_1_type->writeAndGenType(*storage_GraphStorageService_getProps_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(storage_GraphStorageService_getProps_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::storage::cpp2::GraphStorageServiceSvIf>::gen_addVertices(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "addVertices"; + auto func_ret_type = std::make_unique>("storage.ExecResponse"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField storage_GraphStorageService_addVertices_req_1; + storage_GraphStorageService_addVertices_req_1.id_ref() = 1; + storage_GraphStorageService_addVertices_req_1.name_ref() = "req"; + storage_GraphStorageService_addVertices_req_1.is_optional_ref() = false; + auto storage_GraphStorageService_addVertices_req_1_type = std::make_unique>("storage.AddVerticesRequest"); + storage_GraphStorageService_addVertices_req_1_type->writeAndGenType(*storage_GraphStorageService_addVertices_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(storage_GraphStorageService_addVertices_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::storage::cpp2::GraphStorageServiceSvIf>::gen_addEdges(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "addEdges"; + auto func_ret_type = std::make_unique>("storage.ExecResponse"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField storage_GraphStorageService_addEdges_req_1; + storage_GraphStorageService_addEdges_req_1.id_ref() = 1; + storage_GraphStorageService_addEdges_req_1.name_ref() = "req"; + storage_GraphStorageService_addEdges_req_1.is_optional_ref() = false; + auto storage_GraphStorageService_addEdges_req_1_type = std::make_unique>("storage.AddEdgesRequest"); + storage_GraphStorageService_addEdges_req_1_type->writeAndGenType(*storage_GraphStorageService_addEdges_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(storage_GraphStorageService_addEdges_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::storage::cpp2::GraphStorageServiceSvIf>::gen_deleteEdges(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "deleteEdges"; + auto func_ret_type = std::make_unique>("storage.ExecResponse"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField storage_GraphStorageService_deleteEdges_req_1; + storage_GraphStorageService_deleteEdges_req_1.id_ref() = 1; + storage_GraphStorageService_deleteEdges_req_1.name_ref() = "req"; + storage_GraphStorageService_deleteEdges_req_1.is_optional_ref() = false; + auto storage_GraphStorageService_deleteEdges_req_1_type = std::make_unique>("storage.DeleteEdgesRequest"); + storage_GraphStorageService_deleteEdges_req_1_type->writeAndGenType(*storage_GraphStorageService_deleteEdges_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(storage_GraphStorageService_deleteEdges_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::storage::cpp2::GraphStorageServiceSvIf>::gen_deleteVertices(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "deleteVertices"; + auto func_ret_type = std::make_unique>("storage.ExecResponse"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField storage_GraphStorageService_deleteVertices_req_1; + storage_GraphStorageService_deleteVertices_req_1.id_ref() = 1; + storage_GraphStorageService_deleteVertices_req_1.name_ref() = "req"; + storage_GraphStorageService_deleteVertices_req_1.is_optional_ref() = false; + auto storage_GraphStorageService_deleteVertices_req_1_type = std::make_unique>("storage.DeleteVerticesRequest"); + storage_GraphStorageService_deleteVertices_req_1_type->writeAndGenType(*storage_GraphStorageService_deleteVertices_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(storage_GraphStorageService_deleteVertices_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::storage::cpp2::GraphStorageServiceSvIf>::gen_deleteTags(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "deleteTags"; + auto func_ret_type = std::make_unique>("storage.ExecResponse"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField storage_GraphStorageService_deleteTags_req_1; + storage_GraphStorageService_deleteTags_req_1.id_ref() = 1; + storage_GraphStorageService_deleteTags_req_1.name_ref() = "req"; + storage_GraphStorageService_deleteTags_req_1.is_optional_ref() = false; + auto storage_GraphStorageService_deleteTags_req_1_type = std::make_unique>("storage.DeleteTagsRequest"); + storage_GraphStorageService_deleteTags_req_1_type->writeAndGenType(*storage_GraphStorageService_deleteTags_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(storage_GraphStorageService_deleteTags_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::storage::cpp2::GraphStorageServiceSvIf>::gen_updateVertex(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "updateVertex"; + auto func_ret_type = std::make_unique>("storage.UpdateResponse"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField storage_GraphStorageService_updateVertex_req_1; + storage_GraphStorageService_updateVertex_req_1.id_ref() = 1; + storage_GraphStorageService_updateVertex_req_1.name_ref() = "req"; + storage_GraphStorageService_updateVertex_req_1.is_optional_ref() = false; + auto storage_GraphStorageService_updateVertex_req_1_type = std::make_unique>("storage.UpdateVertexRequest"); + storage_GraphStorageService_updateVertex_req_1_type->writeAndGenType(*storage_GraphStorageService_updateVertex_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(storage_GraphStorageService_updateVertex_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::storage::cpp2::GraphStorageServiceSvIf>::gen_updateEdge(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "updateEdge"; + auto func_ret_type = std::make_unique>("storage.UpdateResponse"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField storage_GraphStorageService_updateEdge_req_1; + storage_GraphStorageService_updateEdge_req_1.id_ref() = 1; + storage_GraphStorageService_updateEdge_req_1.name_ref() = "req"; + storage_GraphStorageService_updateEdge_req_1.is_optional_ref() = false; + auto storage_GraphStorageService_updateEdge_req_1_type = std::make_unique>("storage.UpdateEdgeRequest"); + storage_GraphStorageService_updateEdge_req_1_type->writeAndGenType(*storage_GraphStorageService_updateEdge_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(storage_GraphStorageService_updateEdge_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::storage::cpp2::GraphStorageServiceSvIf>::gen_scanVertex(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "scanVertex"; + auto func_ret_type = std::make_unique>("storage.ScanVertexResponse"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField storage_GraphStorageService_scanVertex_req_1; + storage_GraphStorageService_scanVertex_req_1.id_ref() = 1; + storage_GraphStorageService_scanVertex_req_1.name_ref() = "req"; + storage_GraphStorageService_scanVertex_req_1.is_optional_ref() = false; + auto storage_GraphStorageService_scanVertex_req_1_type = std::make_unique>("storage.ScanVertexRequest"); + storage_GraphStorageService_scanVertex_req_1_type->writeAndGenType(*storage_GraphStorageService_scanVertex_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(storage_GraphStorageService_scanVertex_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::storage::cpp2::GraphStorageServiceSvIf>::gen_scanEdge(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "scanEdge"; + auto func_ret_type = std::make_unique>("storage.ScanEdgeResponse"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField storage_GraphStorageService_scanEdge_req_1; + storage_GraphStorageService_scanEdge_req_1.id_ref() = 1; + storage_GraphStorageService_scanEdge_req_1.name_ref() = "req"; + storage_GraphStorageService_scanEdge_req_1.is_optional_ref() = false; + auto storage_GraphStorageService_scanEdge_req_1_type = std::make_unique>("storage.ScanEdgeRequest"); + storage_GraphStorageService_scanEdge_req_1_type->writeAndGenType(*storage_GraphStorageService_scanEdge_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(storage_GraphStorageService_scanEdge_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::storage::cpp2::GraphStorageServiceSvIf>::gen_getUUID(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "getUUID"; + auto func_ret_type = std::make_unique>("storage.GetUUIDResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField storage_GraphStorageService_getUUID_req_1; + storage_GraphStorageService_getUUID_req_1.id_ref() = 1; + storage_GraphStorageService_getUUID_req_1.name_ref() = "req"; + storage_GraphStorageService_getUUID_req_1.is_optional_ref() = false; + auto storage_GraphStorageService_getUUID_req_1_type = std::make_unique>("storage.GetUUIDReq"); + storage_GraphStorageService_getUUID_req_1_type->writeAndGenType(*storage_GraphStorageService_getUUID_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(storage_GraphStorageService_getUUID_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::storage::cpp2::GraphStorageServiceSvIf>::gen_lookupIndex(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "lookupIndex"; + auto func_ret_type = std::make_unique>("storage.LookupIndexResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField storage_GraphStorageService_lookupIndex_req_1; + storage_GraphStorageService_lookupIndex_req_1.id_ref() = 1; + storage_GraphStorageService_lookupIndex_req_1.name_ref() = "req"; + storage_GraphStorageService_lookupIndex_req_1.is_optional_ref() = false; + auto storage_GraphStorageService_lookupIndex_req_1_type = std::make_unique>("storage.LookupIndexRequest"); + storage_GraphStorageService_lookupIndex_req_1_type->writeAndGenType(*storage_GraphStorageService_lookupIndex_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(storage_GraphStorageService_lookupIndex_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::storage::cpp2::GraphStorageServiceSvIf>::gen_lookupAndTraverse(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "lookupAndTraverse"; + auto func_ret_type = std::make_unique>("storage.GetNeighborsResponse"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField storage_GraphStorageService_lookupAndTraverse_req_1; + storage_GraphStorageService_lookupAndTraverse_req_1.id_ref() = 1; + storage_GraphStorageService_lookupAndTraverse_req_1.name_ref() = "req"; + storage_GraphStorageService_lookupAndTraverse_req_1.is_optional_ref() = false; + auto storage_GraphStorageService_lookupAndTraverse_req_1_type = std::make_unique>("storage.LookupAndTraverseRequest"); + storage_GraphStorageService_lookupAndTraverse_req_1_type->writeAndGenType(*storage_GraphStorageService_lookupAndTraverse_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(storage_GraphStorageService_lookupAndTraverse_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::storage::cpp2::GraphStorageServiceSvIf>::gen_chainUpdateEdge(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "chainUpdateEdge"; + auto func_ret_type = std::make_unique>("storage.UpdateResponse"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField storage_GraphStorageService_chainUpdateEdge_req_1; + storage_GraphStorageService_chainUpdateEdge_req_1.id_ref() = 1; + storage_GraphStorageService_chainUpdateEdge_req_1.name_ref() = "req"; + storage_GraphStorageService_chainUpdateEdge_req_1.is_optional_ref() = false; + auto storage_GraphStorageService_chainUpdateEdge_req_1_type = std::make_unique>("storage.UpdateEdgeRequest"); + storage_GraphStorageService_chainUpdateEdge_req_1_type->writeAndGenType(*storage_GraphStorageService_chainUpdateEdge_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(storage_GraphStorageService_chainUpdateEdge_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::storage::cpp2::GraphStorageServiceSvIf>::gen_chainAddEdges(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "chainAddEdges"; + auto func_ret_type = std::make_unique>("storage.ExecResponse"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField storage_GraphStorageService_chainAddEdges_req_1; + storage_GraphStorageService_chainAddEdges_req_1.id_ref() = 1; + storage_GraphStorageService_chainAddEdges_req_1.name_ref() = "req"; + storage_GraphStorageService_chainAddEdges_req_1.is_optional_ref() = false; + auto storage_GraphStorageService_chainAddEdges_req_1_type = std::make_unique>("storage.AddEdgesRequest"); + storage_GraphStorageService_chainAddEdges_req_1_type->writeAndGenType(*storage_GraphStorageService_chainAddEdges_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(storage_GraphStorageService_chainAddEdges_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} + +void ServiceMetadata<::nebula::storage::cpp2::GraphStorageServiceSvIf>::gen(ThriftMetadata& metadata, ThriftServiceContext& context) { + (void) metadata; + ::apache::thrift::metadata::ThriftService storage_GraphStorageService; + storage_GraphStorageService.name_ref() = "storage.GraphStorageService"; + static const ThriftFunctionGenerator functions[] = { + ServiceMetadata<::nebula::storage::cpp2::GraphStorageServiceSvIf>::gen_getNeighbors, + ServiceMetadata<::nebula::storage::cpp2::GraphStorageServiceSvIf>::gen_getProps, + ServiceMetadata<::nebula::storage::cpp2::GraphStorageServiceSvIf>::gen_addVertices, + ServiceMetadata<::nebula::storage::cpp2::GraphStorageServiceSvIf>::gen_addEdges, + ServiceMetadata<::nebula::storage::cpp2::GraphStorageServiceSvIf>::gen_deleteEdges, + ServiceMetadata<::nebula::storage::cpp2::GraphStorageServiceSvIf>::gen_deleteVertices, + ServiceMetadata<::nebula::storage::cpp2::GraphStorageServiceSvIf>::gen_deleteTags, + ServiceMetadata<::nebula::storage::cpp2::GraphStorageServiceSvIf>::gen_updateVertex, + ServiceMetadata<::nebula::storage::cpp2::GraphStorageServiceSvIf>::gen_updateEdge, + ServiceMetadata<::nebula::storage::cpp2::GraphStorageServiceSvIf>::gen_scanVertex, + ServiceMetadata<::nebula::storage::cpp2::GraphStorageServiceSvIf>::gen_scanEdge, + ServiceMetadata<::nebula::storage::cpp2::GraphStorageServiceSvIf>::gen_getUUID, + ServiceMetadata<::nebula::storage::cpp2::GraphStorageServiceSvIf>::gen_lookupIndex, + ServiceMetadata<::nebula::storage::cpp2::GraphStorageServiceSvIf>::gen_lookupAndTraverse, + ServiceMetadata<::nebula::storage::cpp2::GraphStorageServiceSvIf>::gen_chainUpdateEdge, + ServiceMetadata<::nebula::storage::cpp2::GraphStorageServiceSvIf>::gen_chainAddEdges, + }; + for (auto& function_gen : functions) { + function_gen(metadata, storage_GraphStorageService); + } + context.service_info_ref() = std::move(storage_GraphStorageService); + ::apache::thrift::metadata::ThriftModuleContext module; + module.name_ref() = "storage"; + context.module_ref() = std::move(module); +} +void ServiceMetadata<::nebula::storage::cpp2::StorageAdminServiceSvIf>::gen_transLeader(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "transLeader"; + auto func_ret_type = std::make_unique>("storage.AdminExecResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField storage_StorageAdminService_transLeader_req_1; + storage_StorageAdminService_transLeader_req_1.id_ref() = 1; + storage_StorageAdminService_transLeader_req_1.name_ref() = "req"; + storage_StorageAdminService_transLeader_req_1.is_optional_ref() = false; + auto storage_StorageAdminService_transLeader_req_1_type = std::make_unique>("storage.TransLeaderReq"); + storage_StorageAdminService_transLeader_req_1_type->writeAndGenType(*storage_StorageAdminService_transLeader_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(storage_StorageAdminService_transLeader_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::storage::cpp2::StorageAdminServiceSvIf>::gen_addPart(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "addPart"; + auto func_ret_type = std::make_unique>("storage.AdminExecResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField storage_StorageAdminService_addPart_req_1; + storage_StorageAdminService_addPart_req_1.id_ref() = 1; + storage_StorageAdminService_addPart_req_1.name_ref() = "req"; + storage_StorageAdminService_addPart_req_1.is_optional_ref() = false; + auto storage_StorageAdminService_addPart_req_1_type = std::make_unique>("storage.AddPartReq"); + storage_StorageAdminService_addPart_req_1_type->writeAndGenType(*storage_StorageAdminService_addPart_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(storage_StorageAdminService_addPart_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::storage::cpp2::StorageAdminServiceSvIf>::gen_addLearner(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "addLearner"; + auto func_ret_type = std::make_unique>("storage.AdminExecResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField storage_StorageAdminService_addLearner_req_1; + storage_StorageAdminService_addLearner_req_1.id_ref() = 1; + storage_StorageAdminService_addLearner_req_1.name_ref() = "req"; + storage_StorageAdminService_addLearner_req_1.is_optional_ref() = false; + auto storage_StorageAdminService_addLearner_req_1_type = std::make_unique>("storage.AddLearnerReq"); + storage_StorageAdminService_addLearner_req_1_type->writeAndGenType(*storage_StorageAdminService_addLearner_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(storage_StorageAdminService_addLearner_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::storage::cpp2::StorageAdminServiceSvIf>::gen_removePart(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "removePart"; + auto func_ret_type = std::make_unique>("storage.AdminExecResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField storage_StorageAdminService_removePart_req_1; + storage_StorageAdminService_removePart_req_1.id_ref() = 1; + storage_StorageAdminService_removePart_req_1.name_ref() = "req"; + storage_StorageAdminService_removePart_req_1.is_optional_ref() = false; + auto storage_StorageAdminService_removePart_req_1_type = std::make_unique>("storage.RemovePartReq"); + storage_StorageAdminService_removePart_req_1_type->writeAndGenType(*storage_StorageAdminService_removePart_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(storage_StorageAdminService_removePart_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::storage::cpp2::StorageAdminServiceSvIf>::gen_memberChange(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "memberChange"; + auto func_ret_type = std::make_unique>("storage.AdminExecResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField storage_StorageAdminService_memberChange_req_1; + storage_StorageAdminService_memberChange_req_1.id_ref() = 1; + storage_StorageAdminService_memberChange_req_1.name_ref() = "req"; + storage_StorageAdminService_memberChange_req_1.is_optional_ref() = false; + auto storage_StorageAdminService_memberChange_req_1_type = std::make_unique>("storage.MemberChangeReq"); + storage_StorageAdminService_memberChange_req_1_type->writeAndGenType(*storage_StorageAdminService_memberChange_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(storage_StorageAdminService_memberChange_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::storage::cpp2::StorageAdminServiceSvIf>::gen_waitingForCatchUpData(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "waitingForCatchUpData"; + auto func_ret_type = std::make_unique>("storage.AdminExecResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField storage_StorageAdminService_waitingForCatchUpData_req_1; + storage_StorageAdminService_waitingForCatchUpData_req_1.id_ref() = 1; + storage_StorageAdminService_waitingForCatchUpData_req_1.name_ref() = "req"; + storage_StorageAdminService_waitingForCatchUpData_req_1.is_optional_ref() = false; + auto storage_StorageAdminService_waitingForCatchUpData_req_1_type = std::make_unique>("storage.CatchUpDataReq"); + storage_StorageAdminService_waitingForCatchUpData_req_1_type->writeAndGenType(*storage_StorageAdminService_waitingForCatchUpData_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(storage_StorageAdminService_waitingForCatchUpData_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::storage::cpp2::StorageAdminServiceSvIf>::gen_createCheckpoint(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "createCheckpoint"; + auto func_ret_type = std::make_unique>("storage.CreateCPResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField storage_StorageAdminService_createCheckpoint_req_1; + storage_StorageAdminService_createCheckpoint_req_1.id_ref() = 1; + storage_StorageAdminService_createCheckpoint_req_1.name_ref() = "req"; + storage_StorageAdminService_createCheckpoint_req_1.is_optional_ref() = false; + auto storage_StorageAdminService_createCheckpoint_req_1_type = std::make_unique>("storage.CreateCPRequest"); + storage_StorageAdminService_createCheckpoint_req_1_type->writeAndGenType(*storage_StorageAdminService_createCheckpoint_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(storage_StorageAdminService_createCheckpoint_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::storage::cpp2::StorageAdminServiceSvIf>::gen_dropCheckpoint(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "dropCheckpoint"; + auto func_ret_type = std::make_unique>("storage.AdminExecResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField storage_StorageAdminService_dropCheckpoint_req_1; + storage_StorageAdminService_dropCheckpoint_req_1.id_ref() = 1; + storage_StorageAdminService_dropCheckpoint_req_1.name_ref() = "req"; + storage_StorageAdminService_dropCheckpoint_req_1.is_optional_ref() = false; + auto storage_StorageAdminService_dropCheckpoint_req_1_type = std::make_unique>("storage.DropCPRequest"); + storage_StorageAdminService_dropCheckpoint_req_1_type->writeAndGenType(*storage_StorageAdminService_dropCheckpoint_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(storage_StorageAdminService_dropCheckpoint_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::storage::cpp2::StorageAdminServiceSvIf>::gen_blockingWrites(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "blockingWrites"; + auto func_ret_type = std::make_unique>("storage.AdminExecResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField storage_StorageAdminService_blockingWrites_req_1; + storage_StorageAdminService_blockingWrites_req_1.id_ref() = 1; + storage_StorageAdminService_blockingWrites_req_1.name_ref() = "req"; + storage_StorageAdminService_blockingWrites_req_1.is_optional_ref() = false; + auto storage_StorageAdminService_blockingWrites_req_1_type = std::make_unique>("storage.BlockingSignRequest"); + storage_StorageAdminService_blockingWrites_req_1_type->writeAndGenType(*storage_StorageAdminService_blockingWrites_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(storage_StorageAdminService_blockingWrites_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::storage::cpp2::StorageAdminServiceSvIf>::gen_rebuildTagIndex(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "rebuildTagIndex"; + auto func_ret_type = std::make_unique>("storage.AdminExecResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField storage_StorageAdminService_rebuildTagIndex_req_1; + storage_StorageAdminService_rebuildTagIndex_req_1.id_ref() = 1; + storage_StorageAdminService_rebuildTagIndex_req_1.name_ref() = "req"; + storage_StorageAdminService_rebuildTagIndex_req_1.is_optional_ref() = false; + auto storage_StorageAdminService_rebuildTagIndex_req_1_type = std::make_unique>("storage.RebuildIndexRequest"); + storage_StorageAdminService_rebuildTagIndex_req_1_type->writeAndGenType(*storage_StorageAdminService_rebuildTagIndex_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(storage_StorageAdminService_rebuildTagIndex_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::storage::cpp2::StorageAdminServiceSvIf>::gen_rebuildEdgeIndex(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "rebuildEdgeIndex"; + auto func_ret_type = std::make_unique>("storage.AdminExecResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField storage_StorageAdminService_rebuildEdgeIndex_req_1; + storage_StorageAdminService_rebuildEdgeIndex_req_1.id_ref() = 1; + storage_StorageAdminService_rebuildEdgeIndex_req_1.name_ref() = "req"; + storage_StorageAdminService_rebuildEdgeIndex_req_1.is_optional_ref() = false; + auto storage_StorageAdminService_rebuildEdgeIndex_req_1_type = std::make_unique>("storage.RebuildIndexRequest"); + storage_StorageAdminService_rebuildEdgeIndex_req_1_type->writeAndGenType(*storage_StorageAdminService_rebuildEdgeIndex_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(storage_StorageAdminService_rebuildEdgeIndex_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::storage::cpp2::StorageAdminServiceSvIf>::gen_getLeaderParts(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "getLeaderParts"; + auto func_ret_type = std::make_unique>("storage.GetLeaderPartsResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField storage_StorageAdminService_getLeaderParts_req_1; + storage_StorageAdminService_getLeaderParts_req_1.id_ref() = 1; + storage_StorageAdminService_getLeaderParts_req_1.name_ref() = "req"; + storage_StorageAdminService_getLeaderParts_req_1.is_optional_ref() = false; + auto storage_StorageAdminService_getLeaderParts_req_1_type = std::make_unique>("storage.GetLeaderReq"); + storage_StorageAdminService_getLeaderParts_req_1_type->writeAndGenType(*storage_StorageAdminService_getLeaderParts_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(storage_StorageAdminService_getLeaderParts_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::storage::cpp2::StorageAdminServiceSvIf>::gen_checkPeers(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "checkPeers"; + auto func_ret_type = std::make_unique>("storage.AdminExecResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField storage_StorageAdminService_checkPeers_req_1; + storage_StorageAdminService_checkPeers_req_1.id_ref() = 1; + storage_StorageAdminService_checkPeers_req_1.name_ref() = "req"; + storage_StorageAdminService_checkPeers_req_1.is_optional_ref() = false; + auto storage_StorageAdminService_checkPeers_req_1_type = std::make_unique>("storage.CheckPeersReq"); + storage_StorageAdminService_checkPeers_req_1_type->writeAndGenType(*storage_StorageAdminService_checkPeers_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(storage_StorageAdminService_checkPeers_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::storage::cpp2::StorageAdminServiceSvIf>::gen_addAdminTask(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "addAdminTask"; + auto func_ret_type = std::make_unique>("storage.AdminExecResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField storage_StorageAdminService_addAdminTask_req_1; + storage_StorageAdminService_addAdminTask_req_1.id_ref() = 1; + storage_StorageAdminService_addAdminTask_req_1.name_ref() = "req"; + storage_StorageAdminService_addAdminTask_req_1.is_optional_ref() = false; + auto storage_StorageAdminService_addAdminTask_req_1_type = std::make_unique>("storage.AddAdminTaskRequest"); + storage_StorageAdminService_addAdminTask_req_1_type->writeAndGenType(*storage_StorageAdminService_addAdminTask_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(storage_StorageAdminService_addAdminTask_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::storage::cpp2::StorageAdminServiceSvIf>::gen_stopAdminTask(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "stopAdminTask"; + auto func_ret_type = std::make_unique>("storage.AdminExecResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField storage_StorageAdminService_stopAdminTask_req_1; + storage_StorageAdminService_stopAdminTask_req_1.id_ref() = 1; + storage_StorageAdminService_stopAdminTask_req_1.name_ref() = "req"; + storage_StorageAdminService_stopAdminTask_req_1.is_optional_ref() = false; + auto storage_StorageAdminService_stopAdminTask_req_1_type = std::make_unique>("storage.StopAdminTaskRequest"); + storage_StorageAdminService_stopAdminTask_req_1_type->writeAndGenType(*storage_StorageAdminService_stopAdminTask_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(storage_StorageAdminService_stopAdminTask_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::storage::cpp2::StorageAdminServiceSvIf>::gen_listClusterInfo(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "listClusterInfo"; + auto func_ret_type = std::make_unique>("storage.ListClusterInfoResp"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField storage_StorageAdminService_listClusterInfo_req_1; + storage_StorageAdminService_listClusterInfo_req_1.id_ref() = 1; + storage_StorageAdminService_listClusterInfo_req_1.name_ref() = "req"; + storage_StorageAdminService_listClusterInfo_req_1.is_optional_ref() = false; + auto storage_StorageAdminService_listClusterInfo_req_1_type = std::make_unique>("storage.ListClusterInfoReq"); + storage_StorageAdminService_listClusterInfo_req_1_type->writeAndGenType(*storage_StorageAdminService_listClusterInfo_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(storage_StorageAdminService_listClusterInfo_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} + +void ServiceMetadata<::nebula::storage::cpp2::StorageAdminServiceSvIf>::gen(ThriftMetadata& metadata, ThriftServiceContext& context) { + (void) metadata; + ::apache::thrift::metadata::ThriftService storage_StorageAdminService; + storage_StorageAdminService.name_ref() = "storage.StorageAdminService"; + static const ThriftFunctionGenerator functions[] = { + ServiceMetadata<::nebula::storage::cpp2::StorageAdminServiceSvIf>::gen_transLeader, + ServiceMetadata<::nebula::storage::cpp2::StorageAdminServiceSvIf>::gen_addPart, + ServiceMetadata<::nebula::storage::cpp2::StorageAdminServiceSvIf>::gen_addLearner, + ServiceMetadata<::nebula::storage::cpp2::StorageAdminServiceSvIf>::gen_removePart, + ServiceMetadata<::nebula::storage::cpp2::StorageAdminServiceSvIf>::gen_memberChange, + ServiceMetadata<::nebula::storage::cpp2::StorageAdminServiceSvIf>::gen_waitingForCatchUpData, + ServiceMetadata<::nebula::storage::cpp2::StorageAdminServiceSvIf>::gen_createCheckpoint, + ServiceMetadata<::nebula::storage::cpp2::StorageAdminServiceSvIf>::gen_dropCheckpoint, + ServiceMetadata<::nebula::storage::cpp2::StorageAdminServiceSvIf>::gen_blockingWrites, + ServiceMetadata<::nebula::storage::cpp2::StorageAdminServiceSvIf>::gen_rebuildTagIndex, + ServiceMetadata<::nebula::storage::cpp2::StorageAdminServiceSvIf>::gen_rebuildEdgeIndex, + ServiceMetadata<::nebula::storage::cpp2::StorageAdminServiceSvIf>::gen_getLeaderParts, + ServiceMetadata<::nebula::storage::cpp2::StorageAdminServiceSvIf>::gen_checkPeers, + ServiceMetadata<::nebula::storage::cpp2::StorageAdminServiceSvIf>::gen_addAdminTask, + ServiceMetadata<::nebula::storage::cpp2::StorageAdminServiceSvIf>::gen_stopAdminTask, + ServiceMetadata<::nebula::storage::cpp2::StorageAdminServiceSvIf>::gen_listClusterInfo, + }; + for (auto& function_gen : functions) { + function_gen(metadata, storage_StorageAdminService); + } + context.service_info_ref() = std::move(storage_StorageAdminService); + ::apache::thrift::metadata::ThriftModuleContext module; + module.name_ref() = "storage"; + context.module_ref() = std::move(module); +} +void ServiceMetadata<::nebula::storage::cpp2::GeneralStorageServiceSvIf>::gen_get(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "get"; + auto func_ret_type = std::make_unique>("storage.KVGetResponse"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField storage_GeneralStorageService_get_req_1; + storage_GeneralStorageService_get_req_1.id_ref() = 1; + storage_GeneralStorageService_get_req_1.name_ref() = "req"; + storage_GeneralStorageService_get_req_1.is_optional_ref() = false; + auto storage_GeneralStorageService_get_req_1_type = std::make_unique>("storage.KVGetRequest"); + storage_GeneralStorageService_get_req_1_type->writeAndGenType(*storage_GeneralStorageService_get_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(storage_GeneralStorageService_get_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::storage::cpp2::GeneralStorageServiceSvIf>::gen_put(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "put"; + auto func_ret_type = std::make_unique>("storage.ExecResponse"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField storage_GeneralStorageService_put_req_1; + storage_GeneralStorageService_put_req_1.id_ref() = 1; + storage_GeneralStorageService_put_req_1.name_ref() = "req"; + storage_GeneralStorageService_put_req_1.is_optional_ref() = false; + auto storage_GeneralStorageService_put_req_1_type = std::make_unique>("storage.KVPutRequest"); + storage_GeneralStorageService_put_req_1_type->writeAndGenType(*storage_GeneralStorageService_put_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(storage_GeneralStorageService_put_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::storage::cpp2::GeneralStorageServiceSvIf>::gen_remove(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "remove"; + auto func_ret_type = std::make_unique>("storage.ExecResponse"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField storage_GeneralStorageService_remove_req_1; + storage_GeneralStorageService_remove_req_1.id_ref() = 1; + storage_GeneralStorageService_remove_req_1.name_ref() = "req"; + storage_GeneralStorageService_remove_req_1.is_optional_ref() = false; + auto storage_GeneralStorageService_remove_req_1_type = std::make_unique>("storage.KVRemoveRequest"); + storage_GeneralStorageService_remove_req_1_type->writeAndGenType(*storage_GeneralStorageService_remove_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(storage_GeneralStorageService_remove_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} + +void ServiceMetadata<::nebula::storage::cpp2::GeneralStorageServiceSvIf>::gen(ThriftMetadata& metadata, ThriftServiceContext& context) { + (void) metadata; + ::apache::thrift::metadata::ThriftService storage_GeneralStorageService; + storage_GeneralStorageService.name_ref() = "storage.GeneralStorageService"; + static const ThriftFunctionGenerator functions[] = { + ServiceMetadata<::nebula::storage::cpp2::GeneralStorageServiceSvIf>::gen_get, + ServiceMetadata<::nebula::storage::cpp2::GeneralStorageServiceSvIf>::gen_put, + ServiceMetadata<::nebula::storage::cpp2::GeneralStorageServiceSvIf>::gen_remove, + }; + for (auto& function_gen : functions) { + function_gen(metadata, storage_GeneralStorageService); + } + context.service_info_ref() = std::move(storage_GeneralStorageService); + ::apache::thrift::metadata::ThriftModuleContext module; + module.name_ref() = "storage"; + context.module_ref() = std::move(module); +} +void ServiceMetadata<::nebula::storage::cpp2::InternalStorageServiceSvIf>::gen_chainAddEdges(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "chainAddEdges"; + auto func_ret_type = std::make_unique>("storage.ExecResponse"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField storage_InternalStorageService_chainAddEdges_req_1; + storage_InternalStorageService_chainAddEdges_req_1.id_ref() = 1; + storage_InternalStorageService_chainAddEdges_req_1.name_ref() = "req"; + storage_InternalStorageService_chainAddEdges_req_1.is_optional_ref() = false; + auto storage_InternalStorageService_chainAddEdges_req_1_type = std::make_unique>("storage.ChainAddEdgesRequest"); + storage_InternalStorageService_chainAddEdges_req_1_type->writeAndGenType(*storage_InternalStorageService_chainAddEdges_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(storage_InternalStorageService_chainAddEdges_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} +void ServiceMetadata<::nebula::storage::cpp2::InternalStorageServiceSvIf>::gen_chainUpdateEdge(ThriftMetadata& metadata, ThriftService& service) { + ::apache::thrift::metadata::ThriftFunction func; + (void)metadata; + func.name_ref() = "chainUpdateEdge"; + auto func_ret_type = std::make_unique>("storage.UpdateResponse"); + func_ret_type->writeAndGenType(*func.return_type_ref(), metadata); + ::apache::thrift::metadata::ThriftField storage_InternalStorageService_chainUpdateEdge_req_1; + storage_InternalStorageService_chainUpdateEdge_req_1.id_ref() = 1; + storage_InternalStorageService_chainUpdateEdge_req_1.name_ref() = "req"; + storage_InternalStorageService_chainUpdateEdge_req_1.is_optional_ref() = false; + auto storage_InternalStorageService_chainUpdateEdge_req_1_type = std::make_unique>("storage.ChainUpdateEdgeRequest"); + storage_InternalStorageService_chainUpdateEdge_req_1_type->writeAndGenType(*storage_InternalStorageService_chainUpdateEdge_req_1.type_ref(), metadata); + func.arguments_ref()->push_back(std::move(storage_InternalStorageService_chainUpdateEdge_req_1)); + func.is_oneway_ref() = false; + service.functions_ref()->push_back(std::move(func)); +} + +void ServiceMetadata<::nebula::storage::cpp2::InternalStorageServiceSvIf>::gen(ThriftMetadata& metadata, ThriftServiceContext& context) { + (void) metadata; + ::apache::thrift::metadata::ThriftService storage_InternalStorageService; + storage_InternalStorageService.name_ref() = "storage.InternalStorageService"; + static const ThriftFunctionGenerator functions[] = { + ServiceMetadata<::nebula::storage::cpp2::InternalStorageServiceSvIf>::gen_chainAddEdges, + ServiceMetadata<::nebula::storage::cpp2::InternalStorageServiceSvIf>::gen_chainUpdateEdge, + }; + for (auto& function_gen : functions) { + function_gen(metadata, storage_InternalStorageService); + } + context.service_info_ref() = std::move(storage_InternalStorageService); + ::apache::thrift::metadata::ThriftModuleContext module; + module.name_ref() = "storage"; + context.module_ref() = std::move(module); +} +} // namespace md +} // namespace detail +} // namespace thrift +} // namespace apache diff --git a/src/interface/gen-cpp2/storage_metadata.h b/src/interface/gen-cpp2/storage_metadata.h new file mode 100644 index 00000000..ceccf152 --- /dev/null +++ b/src/interface/gen-cpp2/storage_metadata.h @@ -0,0 +1,464 @@ +/** + * Autogenerated by Thrift for storage.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#pragma once + +#include +#include "storage_types.h" +#include "common_metadata.h" +#include "meta_metadata.h" + +namespace nebula { +namespace storage { +namespace cpp2 { +class GraphStorageServiceSvIf; +}}} // namespace nebula::storage::cpp2 +namespace nebula { +namespace storage { +namespace cpp2 { +class StorageAdminServiceSvIf; +}}} // namespace nebula::storage::cpp2 +namespace nebula { +namespace storage { +namespace cpp2 { +class GeneralStorageServiceSvIf; +}}} // namespace nebula::storage::cpp2 +namespace nebula { +namespace storage { +namespace cpp2 { +class InternalStorageServiceSvIf; +}}} // namespace nebula::storage::cpp2 + +namespace apache { +namespace thrift { +namespace detail { +namespace md { + +template <> +class EnumMetadata<::nebula::storage::cpp2::StatType> { + public: + static void gen(ThriftMetadata& metadata); +}; +template <> +class EnumMetadata<::nebula::storage::cpp2::OrderDirection> { + public: + static void gen(ThriftMetadata& metadata); +}; +template <> +class EnumMetadata<::nebula::storage::cpp2::EdgeDirection> { + public: + static void gen(ThriftMetadata& metadata); +}; +template <> +class EnumMetadata<::nebula::storage::cpp2::ScanType> { + public: + static void gen(ThriftMetadata& metadata); +}; +template <> +class EnumMetadata<::nebula::storage::cpp2::EngineSignType> { + public: + static void gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::storage::cpp2::RequestCommon> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::storage::cpp2::PartitionResult> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::storage::cpp2::ResponseCommon> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::storage::cpp2::StatProp> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::storage::cpp2::Expr> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::storage::cpp2::EdgeProp> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::storage::cpp2::VertexProp> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::storage::cpp2::OrderBy> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::storage::cpp2::TraverseSpec> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::storage::cpp2::GetNeighborsRequest> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::storage::cpp2::GetNeighborsResponse> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::storage::cpp2::ExecResponse> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::storage::cpp2::GetPropRequest> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::storage::cpp2::GetPropResponse> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::storage::cpp2::NewTag> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::storage::cpp2::NewVertex> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::storage::cpp2::EdgeKey> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::storage::cpp2::NewEdge> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::storage::cpp2::AddVerticesRequest> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::storage::cpp2::AddEdgesRequest> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::storage::cpp2::DeleteVerticesRequest> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::storage::cpp2::DeleteEdgesRequest> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::storage::cpp2::DelTags> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::storage::cpp2::DeleteTagsRequest> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::storage::cpp2::UpdateResponse> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::storage::cpp2::UpdatedProp> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::storage::cpp2::UpdateVertexRequest> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::storage::cpp2::UpdateEdgeRequest> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::storage::cpp2::GetUUIDReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::storage::cpp2::GetUUIDResp> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::storage::cpp2::LookupIndexResp> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::storage::cpp2::IndexColumnHint> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::storage::cpp2::IndexQueryContext> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::storage::cpp2::IndexSpec> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::storage::cpp2::LookupIndexRequest> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::storage::cpp2::LookupAndTraverseRequest> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::storage::cpp2::ScanVertexRequest> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::storage::cpp2::ScanVertexResponse> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::storage::cpp2::ScanEdgeRequest> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::storage::cpp2::ScanEdgeResponse> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::storage::cpp2::TaskPara> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::storage::cpp2::AddAdminTaskRequest> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::storage::cpp2::StopAdminTaskRequest> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::storage::cpp2::AdminExecResp> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::storage::cpp2::TransLeaderReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::storage::cpp2::AddPartReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::storage::cpp2::AddLearnerReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::storage::cpp2::RemovePartReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::storage::cpp2::MemberChangeReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::storage::cpp2::CatchUpDataReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::storage::cpp2::GetLeaderReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::storage::cpp2::CreateCPRequest> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::storage::cpp2::DropCPRequest> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::storage::cpp2::BlockingSignRequest> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::storage::cpp2::GetLeaderPartsResp> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::storage::cpp2::CheckPeersReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::storage::cpp2::RebuildIndexRequest> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::storage::cpp2::CreateCPResp> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::storage::cpp2::ListClusterInfoResp> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::storage::cpp2::ListClusterInfoReq> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::storage::cpp2::KVGetRequest> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::storage::cpp2::KVGetResponse> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::storage::cpp2::KVPutRequest> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::storage::cpp2::KVRemoveRequest> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::storage::cpp2::InternalTxnRequest> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::storage::cpp2::ChainAddEdgesRequest> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class StructMetadata<::nebula::storage::cpp2::ChainUpdateEdgeRequest> { + public: + static const ::apache::thrift::metadata::ThriftStruct& gen(ThriftMetadata& metadata); +}; +template <> +class ServiceMetadata<::nebula::storage::cpp2::GraphStorageServiceSvIf> { + public: + static void gen(ThriftMetadata& metadata, ThriftServiceContext& context); + private: + static void gen_getNeighbors(ThriftMetadata& metadata, ThriftService& context); + static void gen_getProps(ThriftMetadata& metadata, ThriftService& context); + static void gen_addVertices(ThriftMetadata& metadata, ThriftService& context); + static void gen_addEdges(ThriftMetadata& metadata, ThriftService& context); + static void gen_deleteEdges(ThriftMetadata& metadata, ThriftService& context); + static void gen_deleteVertices(ThriftMetadata& metadata, ThriftService& context); + static void gen_deleteTags(ThriftMetadata& metadata, ThriftService& context); + static void gen_updateVertex(ThriftMetadata& metadata, ThriftService& context); + static void gen_updateEdge(ThriftMetadata& metadata, ThriftService& context); + static void gen_scanVertex(ThriftMetadata& metadata, ThriftService& context); + static void gen_scanEdge(ThriftMetadata& metadata, ThriftService& context); + static void gen_getUUID(ThriftMetadata& metadata, ThriftService& context); + static void gen_lookupIndex(ThriftMetadata& metadata, ThriftService& context); + static void gen_lookupAndTraverse(ThriftMetadata& metadata, ThriftService& context); + static void gen_chainUpdateEdge(ThriftMetadata& metadata, ThriftService& context); + static void gen_chainAddEdges(ThriftMetadata& metadata, ThriftService& context); +}; +template <> +class ServiceMetadata<::nebula::storage::cpp2::StorageAdminServiceSvIf> { + public: + static void gen(ThriftMetadata& metadata, ThriftServiceContext& context); + private: + static void gen_transLeader(ThriftMetadata& metadata, ThriftService& context); + static void gen_addPart(ThriftMetadata& metadata, ThriftService& context); + static void gen_addLearner(ThriftMetadata& metadata, ThriftService& context); + static void gen_removePart(ThriftMetadata& metadata, ThriftService& context); + static void gen_memberChange(ThriftMetadata& metadata, ThriftService& context); + static void gen_waitingForCatchUpData(ThriftMetadata& metadata, ThriftService& context); + static void gen_createCheckpoint(ThriftMetadata& metadata, ThriftService& context); + static void gen_dropCheckpoint(ThriftMetadata& metadata, ThriftService& context); + static void gen_blockingWrites(ThriftMetadata& metadata, ThriftService& context); + static void gen_rebuildTagIndex(ThriftMetadata& metadata, ThriftService& context); + static void gen_rebuildEdgeIndex(ThriftMetadata& metadata, ThriftService& context); + static void gen_getLeaderParts(ThriftMetadata& metadata, ThriftService& context); + static void gen_checkPeers(ThriftMetadata& metadata, ThriftService& context); + static void gen_addAdminTask(ThriftMetadata& metadata, ThriftService& context); + static void gen_stopAdminTask(ThriftMetadata& metadata, ThriftService& context); + static void gen_listClusterInfo(ThriftMetadata& metadata, ThriftService& context); +}; +template <> +class ServiceMetadata<::nebula::storage::cpp2::GeneralStorageServiceSvIf> { + public: + static void gen(ThriftMetadata& metadata, ThriftServiceContext& context); + private: + static void gen_get(ThriftMetadata& metadata, ThriftService& context); + static void gen_put(ThriftMetadata& metadata, ThriftService& context); + static void gen_remove(ThriftMetadata& metadata, ThriftService& context); +}; +template <> +class ServiceMetadata<::nebula::storage::cpp2::InternalStorageServiceSvIf> { + public: + static void gen(ThriftMetadata& metadata, ThriftServiceContext& context); + private: + static void gen_chainAddEdges(ThriftMetadata& metadata, ThriftService& context); + static void gen_chainUpdateEdge(ThriftMetadata& metadata, ThriftService& context); +}; +} // namespace md +} // namespace detail +} // namespace thrift +} // namespace apache diff --git a/src/interface/gen-cpp2/storage_types.cpp b/src/interface/gen-cpp2/storage_types.cpp new file mode 100644 index 00000000..5608d65c --- /dev/null +++ b/src/interface/gen-cpp2/storage_types.cpp @@ -0,0 +1,8662 @@ +/** + * Autogenerated by Thrift for storage.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#include "storage_types.h" +#include "storage_types.tcc" + +#include + +#include "storage_data.h" + + +namespace apache { namespace thrift { + +constexpr std::size_t const TEnumTraits<::nebula::storage::cpp2::StatType>::size; +folly::Range<::nebula::storage::cpp2::StatType const*> const TEnumTraits<::nebula::storage::cpp2::StatType>::values = folly::range(TEnumDataStorage<::nebula::storage::cpp2::StatType>::values); +folly::Range const TEnumTraits<::nebula::storage::cpp2::StatType>::names = folly::range(TEnumDataStorage<::nebula::storage::cpp2::StatType>::names); + +char const* TEnumTraits<::nebula::storage::cpp2::StatType>::findName(type value) { + using factory = ::nebula::storage::cpp2::_StatType_EnumMapFactory; + static folly::Indestructible const map{ + factory::makeValuesToNamesMap()}; + auto found = map->find(value); + return found == map->end() ? nullptr : found->second; +} + +bool TEnumTraits<::nebula::storage::cpp2::StatType>::findValue(char const* name, type* out) { + using factory = ::nebula::storage::cpp2::_StatType_EnumMapFactory; + static folly::Indestructible const map{ + factory::makeNamesToValuesMap()}; + auto found = map->find(name); + return found == map->end() ? false : (*out = found->second, true); +} + +}} // apache::thrift + +namespace nebula { namespace storage { namespace cpp2 { +FOLLY_PUSH_WARNING +FOLLY_GNU_DISABLE_WARNING("-Wdeprecated-declarations") +const _StatType_EnumMapFactory::ValuesToNamesMapType _StatType_VALUES_TO_NAMES = _StatType_EnumMapFactory::makeValuesToNamesMap(); +const _StatType_EnumMapFactory::NamesToValuesMapType _StatType_NAMES_TO_VALUES = _StatType_EnumMapFactory::makeNamesToValuesMap(); +FOLLY_POP_WARNING + +}}} // nebula::storage::cpp2 + +namespace apache { namespace thrift { + +constexpr std::size_t const TEnumTraits<::nebula::storage::cpp2::OrderDirection>::size; +folly::Range<::nebula::storage::cpp2::OrderDirection const*> const TEnumTraits<::nebula::storage::cpp2::OrderDirection>::values = folly::range(TEnumDataStorage<::nebula::storage::cpp2::OrderDirection>::values); +folly::Range const TEnumTraits<::nebula::storage::cpp2::OrderDirection>::names = folly::range(TEnumDataStorage<::nebula::storage::cpp2::OrderDirection>::names); + +char const* TEnumTraits<::nebula::storage::cpp2::OrderDirection>::findName(type value) { + using factory = ::nebula::storage::cpp2::_OrderDirection_EnumMapFactory; + static folly::Indestructible const map{ + factory::makeValuesToNamesMap()}; + auto found = map->find(value); + return found == map->end() ? nullptr : found->second; +} + +bool TEnumTraits<::nebula::storage::cpp2::OrderDirection>::findValue(char const* name, type* out) { + using factory = ::nebula::storage::cpp2::_OrderDirection_EnumMapFactory; + static folly::Indestructible const map{ + factory::makeNamesToValuesMap()}; + auto found = map->find(name); + return found == map->end() ? false : (*out = found->second, true); +} + +}} // apache::thrift + +namespace nebula { namespace storage { namespace cpp2 { +FOLLY_PUSH_WARNING +FOLLY_GNU_DISABLE_WARNING("-Wdeprecated-declarations") +const _OrderDirection_EnumMapFactory::ValuesToNamesMapType _OrderDirection_VALUES_TO_NAMES = _OrderDirection_EnumMapFactory::makeValuesToNamesMap(); +const _OrderDirection_EnumMapFactory::NamesToValuesMapType _OrderDirection_NAMES_TO_VALUES = _OrderDirection_EnumMapFactory::makeNamesToValuesMap(); +FOLLY_POP_WARNING + +}}} // nebula::storage::cpp2 + +namespace apache { namespace thrift { + +constexpr std::size_t const TEnumTraits<::nebula::storage::cpp2::EdgeDirection>::size; +folly::Range<::nebula::storage::cpp2::EdgeDirection const*> const TEnumTraits<::nebula::storage::cpp2::EdgeDirection>::values = folly::range(TEnumDataStorage<::nebula::storage::cpp2::EdgeDirection>::values); +folly::Range const TEnumTraits<::nebula::storage::cpp2::EdgeDirection>::names = folly::range(TEnumDataStorage<::nebula::storage::cpp2::EdgeDirection>::names); + +char const* TEnumTraits<::nebula::storage::cpp2::EdgeDirection>::findName(type value) { + using factory = ::nebula::storage::cpp2::_EdgeDirection_EnumMapFactory; + static folly::Indestructible const map{ + factory::makeValuesToNamesMap()}; + auto found = map->find(value); + return found == map->end() ? nullptr : found->second; +} + +bool TEnumTraits<::nebula::storage::cpp2::EdgeDirection>::findValue(char const* name, type* out) { + using factory = ::nebula::storage::cpp2::_EdgeDirection_EnumMapFactory; + static folly::Indestructible const map{ + factory::makeNamesToValuesMap()}; + auto found = map->find(name); + return found == map->end() ? false : (*out = found->second, true); +} + +}} // apache::thrift + +namespace nebula { namespace storage { namespace cpp2 { +FOLLY_PUSH_WARNING +FOLLY_GNU_DISABLE_WARNING("-Wdeprecated-declarations") +const _EdgeDirection_EnumMapFactory::ValuesToNamesMapType _EdgeDirection_VALUES_TO_NAMES = _EdgeDirection_EnumMapFactory::makeValuesToNamesMap(); +const _EdgeDirection_EnumMapFactory::NamesToValuesMapType _EdgeDirection_NAMES_TO_VALUES = _EdgeDirection_EnumMapFactory::makeNamesToValuesMap(); +FOLLY_POP_WARNING + +}}} // nebula::storage::cpp2 + +namespace apache { namespace thrift { + +constexpr std::size_t const TEnumTraits<::nebula::storage::cpp2::ScanType>::size; +folly::Range<::nebula::storage::cpp2::ScanType const*> const TEnumTraits<::nebula::storage::cpp2::ScanType>::values = folly::range(TEnumDataStorage<::nebula::storage::cpp2::ScanType>::values); +folly::Range const TEnumTraits<::nebula::storage::cpp2::ScanType>::names = folly::range(TEnumDataStorage<::nebula::storage::cpp2::ScanType>::names); + +char const* TEnumTraits<::nebula::storage::cpp2::ScanType>::findName(type value) { + using factory = ::nebula::storage::cpp2::_ScanType_EnumMapFactory; + static folly::Indestructible const map{ + factory::makeValuesToNamesMap()}; + auto found = map->find(value); + return found == map->end() ? nullptr : found->second; +} + +bool TEnumTraits<::nebula::storage::cpp2::ScanType>::findValue(char const* name, type* out) { + using factory = ::nebula::storage::cpp2::_ScanType_EnumMapFactory; + static folly::Indestructible const map{ + factory::makeNamesToValuesMap()}; + auto found = map->find(name); + return found == map->end() ? false : (*out = found->second, true); +} + +}} // apache::thrift + +namespace nebula { namespace storage { namespace cpp2 { +FOLLY_PUSH_WARNING +FOLLY_GNU_DISABLE_WARNING("-Wdeprecated-declarations") +const _ScanType_EnumMapFactory::ValuesToNamesMapType _ScanType_VALUES_TO_NAMES = _ScanType_EnumMapFactory::makeValuesToNamesMap(); +const _ScanType_EnumMapFactory::NamesToValuesMapType _ScanType_NAMES_TO_VALUES = _ScanType_EnumMapFactory::makeNamesToValuesMap(); +FOLLY_POP_WARNING + +}}} // nebula::storage::cpp2 + +namespace apache { namespace thrift { + +constexpr std::size_t const TEnumTraits<::nebula::storage::cpp2::EngineSignType>::size; +folly::Range<::nebula::storage::cpp2::EngineSignType const*> const TEnumTraits<::nebula::storage::cpp2::EngineSignType>::values = folly::range(TEnumDataStorage<::nebula::storage::cpp2::EngineSignType>::values); +folly::Range const TEnumTraits<::nebula::storage::cpp2::EngineSignType>::names = folly::range(TEnumDataStorage<::nebula::storage::cpp2::EngineSignType>::names); + +char const* TEnumTraits<::nebula::storage::cpp2::EngineSignType>::findName(type value) { + using factory = ::nebula::storage::cpp2::_EngineSignType_EnumMapFactory; + static folly::Indestructible const map{ + factory::makeValuesToNamesMap()}; + auto found = map->find(value); + return found == map->end() ? nullptr : found->second; +} + +bool TEnumTraits<::nebula::storage::cpp2::EngineSignType>::findValue(char const* name, type* out) { + using factory = ::nebula::storage::cpp2::_EngineSignType_EnumMapFactory; + static folly::Indestructible const map{ + factory::makeNamesToValuesMap()}; + auto found = map->find(name); + return found == map->end() ? false : (*out = found->second, true); +} + +}} // apache::thrift + +namespace nebula { namespace storage { namespace cpp2 { +FOLLY_PUSH_WARNING +FOLLY_GNU_DISABLE_WARNING("-Wdeprecated-declarations") +const _EngineSignType_EnumMapFactory::ValuesToNamesMapType _EngineSignType_VALUES_TO_NAMES = _EngineSignType_EnumMapFactory::makeValuesToNamesMap(); +const _EngineSignType_EnumMapFactory::NamesToValuesMapType _EngineSignType_NAMES_TO_VALUES = _EngineSignType_EnumMapFactory::makeNamesToValuesMap(); +FOLLY_POP_WARNING + +}}} // nebula::storage::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::storage::cpp2::RequestCommon>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::storage::cpp2::RequestCommon>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace storage { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +RequestCommon::RequestCommon(apache::thrift::FragileConstructor, ::nebula::cpp2::SessionID session_id__arg, ::nebula::cpp2::ExecutionPlanID plan_id__arg, bool profile_detail__arg) : + session_id(std::move(session_id__arg)), + plan_id(std::move(plan_id__arg)), + profile_detail(std::move(profile_detail__arg)) { + __isset.session_id = true; + __isset.plan_id = true; + __isset.profile_detail = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void RequestCommon::__clear() { + // clear all fields + session_id = 0; + plan_id = 0; + profile_detail = 0; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool RequestCommon::operator==(const RequestCommon& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (lhs.session_id_ref() != rhs.session_id_ref()) { + return false; + } + if (lhs.plan_id_ref() != rhs.plan_id_ref()) { + return false; + } + if (lhs.profile_detail_ref() != rhs.profile_detail_ref()) { + return false; + } + return true; +} + +bool RequestCommon::operator<(const RequestCommon& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (lhs.session_id_ref() != rhs.session_id_ref()) { + return lhs.session_id_ref() < rhs.session_id_ref(); + } + if (lhs.plan_id_ref() != rhs.plan_id_ref()) { + return lhs.plan_id_ref() < rhs.plan_id_ref(); + } + if (lhs.profile_detail_ref() != rhs.profile_detail_ref()) { + return lhs.profile_detail_ref() < rhs.profile_detail_ref(); + } + return false; +} + + +void swap(RequestCommon& a, RequestCommon& b) { + using ::std::swap; + swap(a.session_id_ref().value_unchecked(), b.session_id_ref().value_unchecked()); + swap(a.plan_id_ref().value_unchecked(), b.plan_id_ref().value_unchecked()); + swap(a.profile_detail_ref().value_unchecked(), b.profile_detail_ref().value_unchecked()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void RequestCommon::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t RequestCommon::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t RequestCommon::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t RequestCommon::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void RequestCommon::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t RequestCommon::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t RequestCommon::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t RequestCommon::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::storage::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::storage::cpp2::PartitionResult>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::storage::cpp2::PartitionResult>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace storage { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +PartitionResult::PartitionResult(apache::thrift::FragileConstructor, ::nebula::cpp2::ErrorCode code__arg, ::nebula::cpp2::PartitionID part_id__arg, nebula::HostAddr leader__arg) : + code(std::move(code__arg)), + part_id(std::move(part_id__arg)), + leader(std::move(leader__arg)) { + __isset.leader = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void PartitionResult::__clear() { + // clear all fields + code = ::nebula::cpp2::ErrorCode::SUCCEEDED; + part_id = 0; + leader.__clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool PartitionResult::operator==(const PartitionResult& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.code == rhs.code)) { + return false; + } + if (!(lhs.part_id == rhs.part_id)) { + return false; + } + if (lhs.leader_ref() != rhs.leader_ref()) { + return false; + } + return true; +} + +bool PartitionResult::operator<(const PartitionResult& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.code == rhs.code)) { + return lhs.code < rhs.code; + } + if (!(lhs.part_id == rhs.part_id)) { + return lhs.part_id < rhs.part_id; + } + if (lhs.leader_ref() != rhs.leader_ref()) { + return lhs.leader_ref() < rhs.leader_ref(); + } + return false; +} + +const nebula::HostAddr* PartitionResult::get_leader() const& { + return leader_ref().has_value() ? std::addressof(leader) : nullptr; +} + +nebula::HostAddr* PartitionResult::get_leader() & { + return leader_ref().has_value() ? std::addressof(leader) : nullptr; +} + + +void swap(PartitionResult& a, PartitionResult& b) { + using ::std::swap; + swap(a.code_ref().value(), b.code_ref().value()); + swap(a.part_id_ref().value(), b.part_id_ref().value()); + swap(a.leader_ref().value_unchecked(), b.leader_ref().value_unchecked()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void PartitionResult::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t PartitionResult::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t PartitionResult::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t PartitionResult::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void PartitionResult::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t PartitionResult::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t PartitionResult::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t PartitionResult::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + PartitionResult, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + PartitionResult, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of nimble option"); + +}}} // nebula::storage::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::storage::cpp2::ResponseCommon>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::storage::cpp2::ResponseCommon>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace storage { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +ResponseCommon::ResponseCommon(apache::thrift::FragileConstructor, ::std::vector< ::nebula::storage::cpp2::PartitionResult> failed_parts__arg, int32_t latency_in_us__arg, ::std::map<::std::string, int32_t> latency_detail_us__arg) : + failed_parts(std::move(failed_parts__arg)), + latency_in_us(std::move(latency_in_us__arg)), + latency_detail_us(std::move(latency_detail_us__arg)) { + __isset.latency_detail_us = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void ResponseCommon::__clear() { + // clear all fields + failed_parts.clear(); + latency_in_us = 0; + latency_detail_us.clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool ResponseCommon::operator==(const ResponseCommon& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.failed_parts == rhs.failed_parts)) { + return false; + } + if (!(lhs.latency_in_us == rhs.latency_in_us)) { + return false; + } + if (lhs.latency_detail_us_ref() != rhs.latency_detail_us_ref()) { + return false; + } + return true; +} + +bool ResponseCommon::operator<(const ResponseCommon& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.failed_parts == rhs.failed_parts)) { + return lhs.failed_parts < rhs.failed_parts; + } + if (!(lhs.latency_in_us == rhs.latency_in_us)) { + return lhs.latency_in_us < rhs.latency_in_us; + } + if (lhs.latency_detail_us_ref() != rhs.latency_detail_us_ref()) { + return lhs.latency_detail_us_ref() < rhs.latency_detail_us_ref(); + } + return false; +} + +const ::std::vector< ::nebula::storage::cpp2::PartitionResult>& ResponseCommon::get_failed_parts() const& { + return failed_parts; +} + +::std::vector< ::nebula::storage::cpp2::PartitionResult> ResponseCommon::get_failed_parts() && { + return std::move(failed_parts); +} + +const ::std::map<::std::string, int32_t>* ResponseCommon::get_latency_detail_us() const& { + return latency_detail_us_ref().has_value() ? std::addressof(latency_detail_us) : nullptr; +} + +::std::map<::std::string, int32_t>* ResponseCommon::get_latency_detail_us() & { + return latency_detail_us_ref().has_value() ? std::addressof(latency_detail_us) : nullptr; +} + + +void swap(ResponseCommon& a, ResponseCommon& b) { + using ::std::swap; + swap(a.failed_parts_ref().value(), b.failed_parts_ref().value()); + swap(a.latency_in_us_ref().value(), b.latency_in_us_ref().value()); + swap(a.latency_detail_us_ref().value_unchecked(), b.latency_detail_us_ref().value_unchecked()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void ResponseCommon::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t ResponseCommon::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t ResponseCommon::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t ResponseCommon::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void ResponseCommon::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t ResponseCommon::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t ResponseCommon::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t ResponseCommon::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + ResponseCommon, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector< ::nebula::storage::cpp2::PartitionResult>>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + ResponseCommon, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector< ::nebula::storage::cpp2::PartitionResult>>, + "inconsistent use of nimble option"); + +}}} // nebula::storage::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::storage::cpp2::StatProp>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::storage::cpp2::StatProp>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace storage { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +StatProp::StatProp(apache::thrift::FragileConstructor, ::std::string alias__arg, ::std::string prop__arg, ::nebula::storage::cpp2::StatType stat__arg) : + alias(std::move(alias__arg)), + prop(std::move(prop__arg)), + stat(std::move(stat__arg)) { + __isset.alias = true; + __isset.prop = true; + __isset.stat = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void StatProp::__clear() { + // clear all fields + alias = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); + prop = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); + stat = static_cast< ::nebula::storage::cpp2::StatType>(0); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool StatProp::operator==(const StatProp& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!apache::thrift::StringTraits::isEqual(lhs.alias, rhs.alias)) { + return false; + } + if (!apache::thrift::StringTraits::isEqual(lhs.prop, rhs.prop)) { + return false; + } + if (!(lhs.stat == rhs.stat)) { + return false; + } + return true; +} + +bool StatProp::operator<(const StatProp& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!apache::thrift::StringTraits::isEqual(lhs.alias, rhs.alias)) { + return apache::thrift::StringTraits::isLess(lhs.alias, rhs.alias); + } + if (!apache::thrift::StringTraits::isEqual(lhs.prop, rhs.prop)) { + return apache::thrift::StringTraits::isLess(lhs.prop, rhs.prop); + } + if (!(lhs.stat == rhs.stat)) { + return lhs.stat < rhs.stat; + } + return false; +} + + +void swap(StatProp& a, StatProp& b) { + using ::std::swap; + swap(a.alias_ref().value(), b.alias_ref().value()); + swap(a.prop_ref().value(), b.prop_ref().value()); + swap(a.stat_ref().value(), b.stat_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void StatProp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t StatProp::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t StatProp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t StatProp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void StatProp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t StatProp::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t StatProp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t StatProp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::storage::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::storage::cpp2::Expr>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::storage::cpp2::Expr>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace storage { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +Expr::Expr(apache::thrift::FragileConstructor, ::std::string alias__arg, ::std::string expr__arg) : + alias(std::move(alias__arg)), + expr(std::move(expr__arg)) { + __isset.alias = true; + __isset.expr = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void Expr::__clear() { + // clear all fields + alias = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); + expr = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool Expr::operator==(const Expr& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!apache::thrift::StringTraits::isEqual(lhs.alias, rhs.alias)) { + return false; + } + if (!apache::thrift::StringTraits::isEqual(lhs.expr, rhs.expr)) { + return false; + } + return true; +} + +bool Expr::operator<(const Expr& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!apache::thrift::StringTraits::isEqual(lhs.alias, rhs.alias)) { + return apache::thrift::StringTraits::isLess(lhs.alias, rhs.alias); + } + if (!apache::thrift::StringTraits::isEqual(lhs.expr, rhs.expr)) { + return apache::thrift::StringTraits::isLess(lhs.expr, rhs.expr); + } + return false; +} + + +void swap(Expr& a, Expr& b) { + using ::std::swap; + swap(a.alias_ref().value(), b.alias_ref().value()); + swap(a.expr_ref().value(), b.expr_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void Expr::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t Expr::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t Expr::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t Expr::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void Expr::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t Expr::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t Expr::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t Expr::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::storage::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::storage::cpp2::EdgeProp>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::storage::cpp2::EdgeProp>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace storage { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +EdgeProp::EdgeProp(apache::thrift::FragileConstructor, ::nebula::cpp2::EdgeType type__arg, ::std::vector<::std::string> props__arg) : + type(std::move(type__arg)), + props(std::move(props__arg)) { + __isset.type = true; + __isset.props = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void EdgeProp::__clear() { + // clear all fields + type = 0; + props.clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool EdgeProp::operator==(const EdgeProp& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.type == rhs.type)) { + return false; + } + if (!(lhs.props == rhs.props)) { + return false; + } + return true; +} + +bool EdgeProp::operator<(const EdgeProp& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.type == rhs.type)) { + return lhs.type < rhs.type; + } + if (!(lhs.props == rhs.props)) { + return lhs.props < rhs.props; + } + return false; +} + +const ::std::vector<::std::string>& EdgeProp::get_props() const& { + return props; +} + +::std::vector<::std::string> EdgeProp::get_props() && { + return std::move(props); +} + + +void swap(EdgeProp& a, EdgeProp& b) { + using ::std::swap; + swap(a.type_ref().value(), b.type_ref().value()); + swap(a.props_ref().value(), b.props_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void EdgeProp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t EdgeProp::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t EdgeProp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t EdgeProp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void EdgeProp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t EdgeProp::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t EdgeProp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t EdgeProp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::storage::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::storage::cpp2::VertexProp>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::storage::cpp2::VertexProp>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace storage { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +VertexProp::VertexProp(apache::thrift::FragileConstructor, ::nebula::cpp2::TagID tag__arg, ::std::vector<::std::string> props__arg) : + tag(std::move(tag__arg)), + props(std::move(props__arg)) { + __isset.tag = true; + __isset.props = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void VertexProp::__clear() { + // clear all fields + tag = 0; + props.clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool VertexProp::operator==(const VertexProp& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.tag == rhs.tag)) { + return false; + } + if (!(lhs.props == rhs.props)) { + return false; + } + return true; +} + +bool VertexProp::operator<(const VertexProp& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.tag == rhs.tag)) { + return lhs.tag < rhs.tag; + } + if (!(lhs.props == rhs.props)) { + return lhs.props < rhs.props; + } + return false; +} + +const ::std::vector<::std::string>& VertexProp::get_props() const& { + return props; +} + +::std::vector<::std::string> VertexProp::get_props() && { + return std::move(props); +} + + +void swap(VertexProp& a, VertexProp& b) { + using ::std::swap; + swap(a.tag_ref().value(), b.tag_ref().value()); + swap(a.props_ref().value(), b.props_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void VertexProp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t VertexProp::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t VertexProp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t VertexProp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void VertexProp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t VertexProp::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t VertexProp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t VertexProp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::storage::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::storage::cpp2::OrderBy>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::storage::cpp2::OrderBy>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace storage { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +OrderBy::OrderBy(apache::thrift::FragileConstructor, ::std::string prop__arg, ::nebula::storage::cpp2::OrderDirection direction__arg) : + prop(std::move(prop__arg)), + direction(std::move(direction__arg)) { + __isset.prop = true; + __isset.direction = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void OrderBy::__clear() { + // clear all fields + prop = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); + direction = static_cast< ::nebula::storage::cpp2::OrderDirection>(0); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool OrderBy::operator==(const OrderBy& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!apache::thrift::StringTraits::isEqual(lhs.prop, rhs.prop)) { + return false; + } + if (!(lhs.direction == rhs.direction)) { + return false; + } + return true; +} + +bool OrderBy::operator<(const OrderBy& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!apache::thrift::StringTraits::isEqual(lhs.prop, rhs.prop)) { + return apache::thrift::StringTraits::isLess(lhs.prop, rhs.prop); + } + if (!(lhs.direction == rhs.direction)) { + return lhs.direction < rhs.direction; + } + return false; +} + + +void swap(OrderBy& a, OrderBy& b) { + using ::std::swap; + swap(a.prop_ref().value(), b.prop_ref().value()); + swap(a.direction_ref().value(), b.direction_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void OrderBy::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t OrderBy::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t OrderBy::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t OrderBy::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void OrderBy::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t OrderBy::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t OrderBy::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t OrderBy::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::storage::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::storage::cpp2::TraverseSpec>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::storage::cpp2::TraverseSpec>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace storage { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +TraverseSpec::TraverseSpec() : + edge_direction( ::nebula::storage::cpp2::EdgeDirection::BOTH), + dedup(false), + random(0), + limit(0) {} +THRIFT_IGNORE_ISSET_USE_WARNING_END + + +TraverseSpec::~TraverseSpec() {} + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +TraverseSpec::TraverseSpec(apache::thrift::FragileConstructor, ::std::vector< ::nebula::cpp2::EdgeType> edge_types__arg, ::nebula::storage::cpp2::EdgeDirection edge_direction__arg, bool dedup__arg, ::std::vector< ::nebula::storage::cpp2::StatProp> stat_props__arg, ::std::vector< ::nebula::storage::cpp2::VertexProp> vertex_props__arg, ::std::vector< ::nebula::storage::cpp2::EdgeProp> edge_props__arg, ::std::vector< ::nebula::storage::cpp2::Expr> expressions__arg, ::std::vector< ::nebula::storage::cpp2::OrderBy> order_by__arg, bool random__arg, int64_t limit__arg, ::std::string filter__arg) : + edge_types(std::move(edge_types__arg)), + edge_direction(std::move(edge_direction__arg)), + dedup(std::move(dedup__arg)), + stat_props(std::move(stat_props__arg)), + vertex_props(std::move(vertex_props__arg)), + edge_props(std::move(edge_props__arg)), + expressions(std::move(expressions__arg)), + order_by(std::move(order_by__arg)), + random(std::move(random__arg)), + limit(std::move(limit__arg)), + filter(std::move(filter__arg)) { + __isset.edge_types = true; + __isset.edge_direction = true; + __isset.dedup = true; + __isset.stat_props = true; + __isset.vertex_props = true; + __isset.edge_props = true; + __isset.expressions = true; + __isset.order_by = true; + __isset.random = true; + __isset.limit = true; + __isset.filter = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void TraverseSpec::__clear() { + // clear all fields + edge_types.clear(); + edge_direction = ::nebula::storage::cpp2::EdgeDirection::BOTH; + dedup = false; + stat_props.clear(); + vertex_props.clear(); + edge_props.clear(); + expressions.clear(); + order_by.clear(); + random = 0; + limit = 0; + filter = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool TraverseSpec::operator==(const TraverseSpec& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.edge_types == rhs.edge_types)) { + return false; + } + if (!(lhs.edge_direction == rhs.edge_direction)) { + return false; + } + if (!(lhs.dedup == rhs.dedup)) { + return false; + } + if (lhs.stat_props_ref() != rhs.stat_props_ref()) { + return false; + } + if (lhs.vertex_props_ref() != rhs.vertex_props_ref()) { + return false; + } + if (lhs.edge_props_ref() != rhs.edge_props_ref()) { + return false; + } + if (lhs.expressions_ref() != rhs.expressions_ref()) { + return false; + } + if (lhs.order_by_ref() != rhs.order_by_ref()) { + return false; + } + if (lhs.random_ref() != rhs.random_ref()) { + return false; + } + if (lhs.limit_ref() != rhs.limit_ref()) { + return false; + } + if (lhs.filter_ref().has_value() != rhs.filter_ref().has_value()) { + return false; + } + if (lhs.filter_ref().has_value()) { + if (!apache::thrift::StringTraits::isEqual(lhs.filter, rhs.filter)) { + return false; + } + } + return true; +} + +bool TraverseSpec::operator<(const TraverseSpec& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.edge_types == rhs.edge_types)) { + return lhs.edge_types < rhs.edge_types; + } + if (!(lhs.edge_direction == rhs.edge_direction)) { + return lhs.edge_direction < rhs.edge_direction; + } + if (!(lhs.dedup == rhs.dedup)) { + return lhs.dedup < rhs.dedup; + } + if (lhs.stat_props_ref() != rhs.stat_props_ref()) { + return lhs.stat_props_ref() < rhs.stat_props_ref(); + } + if (lhs.vertex_props_ref() != rhs.vertex_props_ref()) { + return lhs.vertex_props_ref() < rhs.vertex_props_ref(); + } + if (lhs.edge_props_ref() != rhs.edge_props_ref()) { + return lhs.edge_props_ref() < rhs.edge_props_ref(); + } + if (lhs.expressions_ref() != rhs.expressions_ref()) { + return lhs.expressions_ref() < rhs.expressions_ref(); + } + if (lhs.order_by_ref() != rhs.order_by_ref()) { + return lhs.order_by_ref() < rhs.order_by_ref(); + } + if (lhs.random_ref() != rhs.random_ref()) { + return lhs.random_ref() < rhs.random_ref(); + } + if (lhs.limit_ref() != rhs.limit_ref()) { + return lhs.limit_ref() < rhs.limit_ref(); + } + if (lhs.filter_ref().has_value() != rhs.filter_ref().has_value()) { + return lhs.filter_ref().has_value() < rhs.filter_ref().has_value(); + } + if (lhs.filter_ref().has_value()) { + if (!apache::thrift::StringTraits::isEqual(lhs.filter, rhs.filter)) { + return apache::thrift::StringTraits::isLess(lhs.filter, rhs.filter); + } + } + return false; +} + +const ::std::vector< ::nebula::cpp2::EdgeType>& TraverseSpec::get_edge_types() const& { + return edge_types; +} + +::std::vector< ::nebula::cpp2::EdgeType> TraverseSpec::get_edge_types() && { + return std::move(edge_types); +} + +const ::std::vector< ::nebula::storage::cpp2::StatProp>* TraverseSpec::get_stat_props() const& { + return stat_props_ref().has_value() ? std::addressof(stat_props) : nullptr; +} + +::std::vector< ::nebula::storage::cpp2::StatProp>* TraverseSpec::get_stat_props() & { + return stat_props_ref().has_value() ? std::addressof(stat_props) : nullptr; +} + +const ::std::vector< ::nebula::storage::cpp2::VertexProp>* TraverseSpec::get_vertex_props() const& { + return vertex_props_ref().has_value() ? std::addressof(vertex_props) : nullptr; +} + +::std::vector< ::nebula::storage::cpp2::VertexProp>* TraverseSpec::get_vertex_props() & { + return vertex_props_ref().has_value() ? std::addressof(vertex_props) : nullptr; +} + +const ::std::vector< ::nebula::storage::cpp2::EdgeProp>* TraverseSpec::get_edge_props() const& { + return edge_props_ref().has_value() ? std::addressof(edge_props) : nullptr; +} + +::std::vector< ::nebula::storage::cpp2::EdgeProp>* TraverseSpec::get_edge_props() & { + return edge_props_ref().has_value() ? std::addressof(edge_props) : nullptr; +} + +const ::std::vector< ::nebula::storage::cpp2::Expr>* TraverseSpec::get_expressions() const& { + return expressions_ref().has_value() ? std::addressof(expressions) : nullptr; +} + +::std::vector< ::nebula::storage::cpp2::Expr>* TraverseSpec::get_expressions() & { + return expressions_ref().has_value() ? std::addressof(expressions) : nullptr; +} + +const ::std::vector< ::nebula::storage::cpp2::OrderBy>* TraverseSpec::get_order_by() const& { + return order_by_ref().has_value() ? std::addressof(order_by) : nullptr; +} + +::std::vector< ::nebula::storage::cpp2::OrderBy>* TraverseSpec::get_order_by() & { + return order_by_ref().has_value() ? std::addressof(order_by) : nullptr; +} + + +void swap(TraverseSpec& a, TraverseSpec& b) { + using ::std::swap; + swap(a.edge_types_ref().value(), b.edge_types_ref().value()); + swap(a.edge_direction_ref().value(), b.edge_direction_ref().value()); + swap(a.dedup_ref().value(), b.dedup_ref().value()); + swap(a.stat_props_ref().value_unchecked(), b.stat_props_ref().value_unchecked()); + swap(a.vertex_props_ref().value_unchecked(), b.vertex_props_ref().value_unchecked()); + swap(a.edge_props_ref().value_unchecked(), b.edge_props_ref().value_unchecked()); + swap(a.expressions_ref().value_unchecked(), b.expressions_ref().value_unchecked()); + swap(a.order_by_ref().value_unchecked(), b.order_by_ref().value_unchecked()); + swap(a.random_ref().value_unchecked(), b.random_ref().value_unchecked()); + swap(a.limit_ref().value_unchecked(), b.limit_ref().value_unchecked()); + swap(a.filter_ref().value_unchecked(), b.filter_ref().value_unchecked()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void TraverseSpec::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t TraverseSpec::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t TraverseSpec::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t TraverseSpec::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void TraverseSpec::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t TraverseSpec::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t TraverseSpec::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t TraverseSpec::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + TraverseSpec, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector< ::nebula::storage::cpp2::StatProp>>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + TraverseSpec, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector< ::nebula::storage::cpp2::VertexProp>>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + TraverseSpec, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector< ::nebula::storage::cpp2::EdgeProp>>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + TraverseSpec, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector< ::nebula::storage::cpp2::Expr>>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + TraverseSpec, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector< ::nebula::storage::cpp2::OrderBy>>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + TraverseSpec, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector< ::nebula::storage::cpp2::StatProp>>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + TraverseSpec, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector< ::nebula::storage::cpp2::VertexProp>>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + TraverseSpec, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector< ::nebula::storage::cpp2::EdgeProp>>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + TraverseSpec, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector< ::nebula::storage::cpp2::Expr>>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + TraverseSpec, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector< ::nebula::storage::cpp2::OrderBy>>, + "inconsistent use of nimble option"); + +}}} // nebula::storage::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::storage::cpp2::GetNeighborsRequest>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::storage::cpp2::GetNeighborsRequest>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace storage { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +GetNeighborsRequest::GetNeighborsRequest() : + space_id(0) {} +THRIFT_IGNORE_ISSET_USE_WARNING_END + + +GetNeighborsRequest::~GetNeighborsRequest() {} + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +GetNeighborsRequest::GetNeighborsRequest(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, ::std::vector<::std::string> column_names__arg, std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector> parts__arg, ::nebula::storage::cpp2::TraverseSpec traverse_spec__arg, ::nebula::storage::cpp2::RequestCommon common__arg) : + space_id(std::move(space_id__arg)), + column_names(std::move(column_names__arg)), + parts(std::move(parts__arg)), + traverse_spec(std::move(traverse_spec__arg)), + common(std::move(common__arg)) { + __isset.space_id = true; + __isset.column_names = true; + __isset.parts = true; + __isset.traverse_spec = true; + __isset.common = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void GetNeighborsRequest::__clear() { + // clear all fields + space_id = 0; + column_names.clear(); + parts.clear(); + traverse_spec.__clear(); + common.__clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool GetNeighborsRequest::operator==(const GetNeighborsRequest& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return false; + } + if (!(lhs.column_names == rhs.column_names)) { + return false; + } + if (!(lhs.parts == rhs.parts)) { + return false; + } + if (!(lhs.traverse_spec == rhs.traverse_spec)) { + return false; + } + if (lhs.common_ref() != rhs.common_ref()) { + return false; + } + return true; +} + +const ::std::vector<::std::string>& GetNeighborsRequest::get_column_names() const& { + return column_names; +} + +::std::vector<::std::string> GetNeighborsRequest::get_column_names() && { + return std::move(column_names); +} + +const std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector>& GetNeighborsRequest::get_parts() const& { + return parts; +} + +std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector> GetNeighborsRequest::get_parts() && { + return std::move(parts); +} + +const ::nebula::storage::cpp2::TraverseSpec& GetNeighborsRequest::get_traverse_spec() const& { + return traverse_spec; +} + + ::nebula::storage::cpp2::TraverseSpec GetNeighborsRequest::get_traverse_spec() && { + return std::move(traverse_spec); +} + +const ::nebula::storage::cpp2::RequestCommon* GetNeighborsRequest::get_common() const& { + return common_ref().has_value() ? std::addressof(common) : nullptr; +} + + ::nebula::storage::cpp2::RequestCommon* GetNeighborsRequest::get_common() & { + return common_ref().has_value() ? std::addressof(common) : nullptr; +} + + +void swap(GetNeighborsRequest& a, GetNeighborsRequest& b) { + using ::std::swap; + swap(a.space_id_ref().value(), b.space_id_ref().value()); + swap(a.column_names_ref().value(), b.column_names_ref().value()); + swap(a.parts_ref().value(), b.parts_ref().value()); + swap(a.traverse_spec_ref().value(), b.traverse_spec_ref().value()); + swap(a.common_ref().value_unchecked(), b.common_ref().value_unchecked()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void GetNeighborsRequest::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t GetNeighborsRequest::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t GetNeighborsRequest::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t GetNeighborsRequest::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void GetNeighborsRequest::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t GetNeighborsRequest::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t GetNeighborsRequest::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t GetNeighborsRequest::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + GetNeighborsRequest, + ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>>, + std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector>>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + GetNeighborsRequest, + ::apache::thrift::type_class::structure, + ::nebula::storage::cpp2::TraverseSpec>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + GetNeighborsRequest, + ::apache::thrift::type_class::structure, + ::nebula::storage::cpp2::RequestCommon>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + GetNeighborsRequest, + ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>>, + std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector>>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + GetNeighborsRequest, + ::apache::thrift::type_class::structure, + ::nebula::storage::cpp2::TraverseSpec>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + GetNeighborsRequest, + ::apache::thrift::type_class::structure, + ::nebula::storage::cpp2::RequestCommon>, + "inconsistent use of nimble option"); + +}}} // nebula::storage::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::storage::cpp2::GetNeighborsResponse>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::storage::cpp2::GetNeighborsResponse>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace storage { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +GetNeighborsResponse::GetNeighborsResponse(apache::thrift::FragileConstructor, ::nebula::storage::cpp2::ResponseCommon result__arg, nebula::DataSet vertices__arg) : + result(std::move(result__arg)), + vertices(std::move(vertices__arg)) { + __isset.vertices = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void GetNeighborsResponse::__clear() { + // clear all fields + result.__clear(); + vertices.__clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool GetNeighborsResponse::operator==(const GetNeighborsResponse& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.result == rhs.result)) { + return false; + } + if (lhs.vertices_ref() != rhs.vertices_ref()) { + return false; + } + return true; +} + +const ::nebula::storage::cpp2::ResponseCommon& GetNeighborsResponse::get_result() const& { + return result; +} + + ::nebula::storage::cpp2::ResponseCommon GetNeighborsResponse::get_result() && { + return std::move(result); +} + +const nebula::DataSet* GetNeighborsResponse::get_vertices() const& { + return vertices_ref().has_value() ? std::addressof(vertices) : nullptr; +} + +nebula::DataSet* GetNeighborsResponse::get_vertices() & { + return vertices_ref().has_value() ? std::addressof(vertices) : nullptr; +} + + +void swap(GetNeighborsResponse& a, GetNeighborsResponse& b) { + using ::std::swap; + swap(a.result_ref().value(), b.result_ref().value()); + swap(a.vertices_ref().value_unchecked(), b.vertices_ref().value_unchecked()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void GetNeighborsResponse::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t GetNeighborsResponse::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t GetNeighborsResponse::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t GetNeighborsResponse::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void GetNeighborsResponse::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t GetNeighborsResponse::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t GetNeighborsResponse::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t GetNeighborsResponse::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + GetNeighborsResponse, + ::apache::thrift::type_class::structure, + ::nebula::storage::cpp2::ResponseCommon>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + GetNeighborsResponse, + ::apache::thrift::type_class::structure, + nebula::DataSet>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + GetNeighborsResponse, + ::apache::thrift::type_class::structure, + ::nebula::storage::cpp2::ResponseCommon>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + GetNeighborsResponse, + ::apache::thrift::type_class::structure, + nebula::DataSet>, + "inconsistent use of nimble option"); + +}}} // nebula::storage::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::storage::cpp2::ExecResponse>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::storage::cpp2::ExecResponse>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace storage { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +ExecResponse::ExecResponse(apache::thrift::FragileConstructor, ::nebula::storage::cpp2::ResponseCommon result__arg) : + result(std::move(result__arg)) {} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void ExecResponse::__clear() { + // clear all fields + result.__clear(); +} + +bool ExecResponse::operator==(const ExecResponse& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.result == rhs.result)) { + return false; + } + return true; +} + +bool ExecResponse::operator<(const ExecResponse& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.result == rhs.result)) { + return lhs.result < rhs.result; + } + return false; +} + +const ::nebula::storage::cpp2::ResponseCommon& ExecResponse::get_result() const& { + return result; +} + + ::nebula::storage::cpp2::ResponseCommon ExecResponse::get_result() && { + return std::move(result); +} + + +void swap(ExecResponse& a, ExecResponse& b) { + using ::std::swap; + swap(a.result_ref().value(), b.result_ref().value()); +} + +template void ExecResponse::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t ExecResponse::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t ExecResponse::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t ExecResponse::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void ExecResponse::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t ExecResponse::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t ExecResponse::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t ExecResponse::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + ExecResponse, + ::apache::thrift::type_class::structure, + ::nebula::storage::cpp2::ResponseCommon>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + ExecResponse, + ::apache::thrift::type_class::structure, + ::nebula::storage::cpp2::ResponseCommon>, + "inconsistent use of nimble option"); + +}}} // nebula::storage::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::storage::cpp2::GetPropRequest>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::storage::cpp2::GetPropRequest>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace storage { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +GetPropRequest::GetPropRequest() : + space_id(0), + dedup(false), + limit(0) {} +THRIFT_IGNORE_ISSET_USE_WARNING_END + + +GetPropRequest::~GetPropRequest() {} + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +GetPropRequest::GetPropRequest(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector> parts__arg, ::std::vector< ::nebula::storage::cpp2::VertexProp> vertex_props__arg, ::std::vector< ::nebula::storage::cpp2::EdgeProp> edge_props__arg, ::std::vector< ::nebula::storage::cpp2::Expr> expressions__arg, bool dedup__arg, ::std::vector< ::nebula::storage::cpp2::OrderBy> order_by__arg, int64_t limit__arg, ::std::string filter__arg, ::nebula::storage::cpp2::RequestCommon common__arg) : + space_id(std::move(space_id__arg)), + parts(std::move(parts__arg)), + vertex_props(std::move(vertex_props__arg)), + edge_props(std::move(edge_props__arg)), + expressions(std::move(expressions__arg)), + dedup(std::move(dedup__arg)), + order_by(std::move(order_by__arg)), + limit(std::move(limit__arg)), + filter(std::move(filter__arg)), + common(std::move(common__arg)) { + __isset.space_id = true; + __isset.parts = true; + __isset.vertex_props = true; + __isset.edge_props = true; + __isset.expressions = true; + __isset.dedup = true; + __isset.order_by = true; + __isset.limit = true; + __isset.filter = true; + __isset.common = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void GetPropRequest::__clear() { + // clear all fields + space_id = 0; + parts.clear(); + vertex_props.clear(); + edge_props.clear(); + expressions.clear(); + dedup = false; + order_by.clear(); + limit = 0; + filter = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); + common.__clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool GetPropRequest::operator==(const GetPropRequest& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return false; + } + if (!(lhs.parts == rhs.parts)) { + return false; + } + if (lhs.vertex_props_ref() != rhs.vertex_props_ref()) { + return false; + } + if (lhs.edge_props_ref() != rhs.edge_props_ref()) { + return false; + } + if (lhs.expressions_ref() != rhs.expressions_ref()) { + return false; + } + if (!(lhs.dedup == rhs.dedup)) { + return false; + } + if (lhs.order_by_ref() != rhs.order_by_ref()) { + return false; + } + if (lhs.limit_ref() != rhs.limit_ref()) { + return false; + } + if (lhs.filter_ref().has_value() != rhs.filter_ref().has_value()) { + return false; + } + if (lhs.filter_ref().has_value()) { + if (!apache::thrift::StringTraits::isEqual(lhs.filter, rhs.filter)) { + return false; + } + } + if (lhs.common_ref() != rhs.common_ref()) { + return false; + } + return true; +} + +const std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector>& GetPropRequest::get_parts() const& { + return parts; +} + +std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector> GetPropRequest::get_parts() && { + return std::move(parts); +} + +const ::std::vector< ::nebula::storage::cpp2::VertexProp>* GetPropRequest::get_vertex_props() const& { + return vertex_props_ref().has_value() ? std::addressof(vertex_props) : nullptr; +} + +::std::vector< ::nebula::storage::cpp2::VertexProp>* GetPropRequest::get_vertex_props() & { + return vertex_props_ref().has_value() ? std::addressof(vertex_props) : nullptr; +} + +const ::std::vector< ::nebula::storage::cpp2::EdgeProp>* GetPropRequest::get_edge_props() const& { + return edge_props_ref().has_value() ? std::addressof(edge_props) : nullptr; +} + +::std::vector< ::nebula::storage::cpp2::EdgeProp>* GetPropRequest::get_edge_props() & { + return edge_props_ref().has_value() ? std::addressof(edge_props) : nullptr; +} + +const ::std::vector< ::nebula::storage::cpp2::Expr>* GetPropRequest::get_expressions() const& { + return expressions_ref().has_value() ? std::addressof(expressions) : nullptr; +} + +::std::vector< ::nebula::storage::cpp2::Expr>* GetPropRequest::get_expressions() & { + return expressions_ref().has_value() ? std::addressof(expressions) : nullptr; +} + +const ::std::vector< ::nebula::storage::cpp2::OrderBy>* GetPropRequest::get_order_by() const& { + return order_by_ref().has_value() ? std::addressof(order_by) : nullptr; +} + +::std::vector< ::nebula::storage::cpp2::OrderBy>* GetPropRequest::get_order_by() & { + return order_by_ref().has_value() ? std::addressof(order_by) : nullptr; +} + +const ::nebula::storage::cpp2::RequestCommon* GetPropRequest::get_common() const& { + return common_ref().has_value() ? std::addressof(common) : nullptr; +} + + ::nebula::storage::cpp2::RequestCommon* GetPropRequest::get_common() & { + return common_ref().has_value() ? std::addressof(common) : nullptr; +} + + +void swap(GetPropRequest& a, GetPropRequest& b) { + using ::std::swap; + swap(a.space_id_ref().value(), b.space_id_ref().value()); + swap(a.parts_ref().value(), b.parts_ref().value()); + swap(a.vertex_props_ref().value_unchecked(), b.vertex_props_ref().value_unchecked()); + swap(a.edge_props_ref().value_unchecked(), b.edge_props_ref().value_unchecked()); + swap(a.expressions_ref().value_unchecked(), b.expressions_ref().value_unchecked()); + swap(a.dedup_ref().value(), b.dedup_ref().value()); + swap(a.order_by_ref().value_unchecked(), b.order_by_ref().value_unchecked()); + swap(a.limit_ref().value_unchecked(), b.limit_ref().value_unchecked()); + swap(a.filter_ref().value_unchecked(), b.filter_ref().value_unchecked()); + swap(a.common_ref().value_unchecked(), b.common_ref().value_unchecked()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void GetPropRequest::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t GetPropRequest::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t GetPropRequest::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t GetPropRequest::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void GetPropRequest::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t GetPropRequest::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t GetPropRequest::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t GetPropRequest::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + GetPropRequest, + ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>>, + std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector>>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + GetPropRequest, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector< ::nebula::storage::cpp2::VertexProp>>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + GetPropRequest, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector< ::nebula::storage::cpp2::EdgeProp>>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + GetPropRequest, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector< ::nebula::storage::cpp2::Expr>>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + GetPropRequest, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector< ::nebula::storage::cpp2::OrderBy>>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + GetPropRequest, + ::apache::thrift::type_class::structure, + ::nebula::storage::cpp2::RequestCommon>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + GetPropRequest, + ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>>, + std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector>>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + GetPropRequest, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector< ::nebula::storage::cpp2::VertexProp>>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + GetPropRequest, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector< ::nebula::storage::cpp2::EdgeProp>>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + GetPropRequest, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector< ::nebula::storage::cpp2::Expr>>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + GetPropRequest, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector< ::nebula::storage::cpp2::OrderBy>>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + GetPropRequest, + ::apache::thrift::type_class::structure, + ::nebula::storage::cpp2::RequestCommon>, + "inconsistent use of nimble option"); + +}}} // nebula::storage::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::storage::cpp2::GetPropResponse>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::storage::cpp2::GetPropResponse>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace storage { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +GetPropResponse::GetPropResponse(apache::thrift::FragileConstructor, ::nebula::storage::cpp2::ResponseCommon result__arg, nebula::DataSet props__arg) : + result(std::move(result__arg)), + props(std::move(props__arg)) { + __isset.result = true; + __isset.props = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void GetPropResponse::__clear() { + // clear all fields + result.__clear(); + props.__clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool GetPropResponse::operator==(const GetPropResponse& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.result == rhs.result)) { + return false; + } + if (lhs.props_ref() != rhs.props_ref()) { + return false; + } + return true; +} + +const ::nebula::storage::cpp2::ResponseCommon& GetPropResponse::get_result() const& { + return result; +} + + ::nebula::storage::cpp2::ResponseCommon GetPropResponse::get_result() && { + return std::move(result); +} + +const nebula::DataSet* GetPropResponse::get_props() const& { + return props_ref().has_value() ? std::addressof(props) : nullptr; +} + +nebula::DataSet* GetPropResponse::get_props() & { + return props_ref().has_value() ? std::addressof(props) : nullptr; +} + + +void swap(GetPropResponse& a, GetPropResponse& b) { + using ::std::swap; + swap(a.result_ref().value(), b.result_ref().value()); + swap(a.props_ref().value_unchecked(), b.props_ref().value_unchecked()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void GetPropResponse::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t GetPropResponse::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t GetPropResponse::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t GetPropResponse::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void GetPropResponse::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t GetPropResponse::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t GetPropResponse::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t GetPropResponse::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + GetPropResponse, + ::apache::thrift::type_class::structure, + ::nebula::storage::cpp2::ResponseCommon>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + GetPropResponse, + ::apache::thrift::type_class::structure, + nebula::DataSet>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + GetPropResponse, + ::apache::thrift::type_class::structure, + ::nebula::storage::cpp2::ResponseCommon>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + GetPropResponse, + ::apache::thrift::type_class::structure, + nebula::DataSet>, + "inconsistent use of nimble option"); + +}}} // nebula::storage::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::storage::cpp2::NewTag>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::storage::cpp2::NewTag>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace storage { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +NewTag::NewTag(apache::thrift::FragileConstructor, ::nebula::cpp2::TagID tag_id__arg, ::std::vector props__arg) : + tag_id(std::move(tag_id__arg)), + props(std::move(props__arg)) { + __isset.tag_id = true; + __isset.props = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void NewTag::__clear() { + // clear all fields + tag_id = 0; + props.clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool NewTag::operator==(const NewTag& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.tag_id == rhs.tag_id)) { + return false; + } + if (!(lhs.props == rhs.props)) { + return false; + } + return true; +} + +const ::std::vector& NewTag::get_props() const& { + return props; +} + +::std::vector NewTag::get_props() && { + return std::move(props); +} + + +void swap(NewTag& a, NewTag& b) { + using ::std::swap; + swap(a.tag_id_ref().value(), b.tag_id_ref().value()); + swap(a.props_ref().value(), b.props_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void NewTag::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t NewTag::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t NewTag::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t NewTag::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void NewTag::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t NewTag::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t NewTag::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t NewTag::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + NewTag, + ::apache::thrift::type_class::list<::apache::thrift::type_class::variant>, + ::std::vector>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + NewTag, + ::apache::thrift::type_class::list<::apache::thrift::type_class::variant>, + ::std::vector>, + "inconsistent use of nimble option"); + +}}} // nebula::storage::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::storage::cpp2::NewVertex>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::storage::cpp2::NewVertex>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace storage { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +NewVertex::NewVertex(apache::thrift::FragileConstructor, nebula::Value id__arg, ::std::vector< ::nebula::storage::cpp2::NewTag> tags__arg) : + id(std::move(id__arg)), + tags(std::move(tags__arg)) { + __isset.id = true; + __isset.tags = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void NewVertex::__clear() { + // clear all fields + id.__clear(); + tags.clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool NewVertex::operator==(const NewVertex& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.id == rhs.id)) { + return false; + } + if (!(lhs.tags == rhs.tags)) { + return false; + } + return true; +} + +const nebula::Value& NewVertex::get_id() const& { + return id; +} + +nebula::Value NewVertex::get_id() && { + return std::move(id); +} + +const ::std::vector< ::nebula::storage::cpp2::NewTag>& NewVertex::get_tags() const& { + return tags; +} + +::std::vector< ::nebula::storage::cpp2::NewTag> NewVertex::get_tags() && { + return std::move(tags); +} + + +void swap(NewVertex& a, NewVertex& b) { + using ::std::swap; + swap(a.id_ref().value(), b.id_ref().value()); + swap(a.tags_ref().value(), b.tags_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void NewVertex::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t NewVertex::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t NewVertex::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t NewVertex::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void NewVertex::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t NewVertex::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t NewVertex::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t NewVertex::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + NewVertex, + ::apache::thrift::type_class::variant, + nebula::Value>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + NewVertex, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector< ::nebula::storage::cpp2::NewTag>>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + NewVertex, + ::apache::thrift::type_class::variant, + nebula::Value>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + NewVertex, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector< ::nebula::storage::cpp2::NewTag>>, + "inconsistent use of nimble option"); + +}}} // nebula::storage::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::storage::cpp2::EdgeKey>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::storage::cpp2::EdgeKey>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace storage { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +EdgeKey::EdgeKey(apache::thrift::FragileConstructor, nebula::Value src__arg, ::nebula::cpp2::EdgeType edge_type__arg, ::nebula::cpp2::EdgeRanking ranking__arg, nebula::Value dst__arg) : + src(std::move(src__arg)), + edge_type(std::move(edge_type__arg)), + ranking(std::move(ranking__arg)), + dst(std::move(dst__arg)) { + __isset.src = true; + __isset.edge_type = true; + __isset.ranking = true; + __isset.dst = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void EdgeKey::__clear() { + // clear all fields + src.__clear(); + edge_type = 0; + ranking = 0; + dst.__clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool EdgeKey::operator==(const EdgeKey& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.src == rhs.src)) { + return false; + } + if (!(lhs.edge_type == rhs.edge_type)) { + return false; + } + if (!(lhs.ranking == rhs.ranking)) { + return false; + } + if (!(lhs.dst == rhs.dst)) { + return false; + } + return true; +} + +const nebula::Value& EdgeKey::get_src() const& { + return src; +} + +nebula::Value EdgeKey::get_src() && { + return std::move(src); +} + +const nebula::Value& EdgeKey::get_dst() const& { + return dst; +} + +nebula::Value EdgeKey::get_dst() && { + return std::move(dst); +} + + +void swap(EdgeKey& a, EdgeKey& b) { + using ::std::swap; + swap(a.src_ref().value(), b.src_ref().value()); + swap(a.edge_type_ref().value(), b.edge_type_ref().value()); + swap(a.ranking_ref().value(), b.ranking_ref().value()); + swap(a.dst_ref().value(), b.dst_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void EdgeKey::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t EdgeKey::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t EdgeKey::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t EdgeKey::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void EdgeKey::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t EdgeKey::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t EdgeKey::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t EdgeKey::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + EdgeKey, + ::apache::thrift::type_class::variant, + nebula::Value>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + EdgeKey, + ::apache::thrift::type_class::variant, + nebula::Value>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + EdgeKey, + ::apache::thrift::type_class::variant, + nebula::Value>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + EdgeKey, + ::apache::thrift::type_class::variant, + nebula::Value>, + "inconsistent use of nimble option"); + +}}} // nebula::storage::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::storage::cpp2::NewEdge>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::storage::cpp2::NewEdge>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace storage { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +NewEdge::NewEdge(apache::thrift::FragileConstructor, ::nebula::storage::cpp2::EdgeKey key__arg, ::std::vector props__arg) : + key(std::move(key__arg)), + props(std::move(props__arg)) { + __isset.key = true; + __isset.props = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void NewEdge::__clear() { + // clear all fields + key.__clear(); + props.clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool NewEdge::operator==(const NewEdge& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.key == rhs.key)) { + return false; + } + if (!(lhs.props == rhs.props)) { + return false; + } + return true; +} + +const ::nebula::storage::cpp2::EdgeKey& NewEdge::get_key() const& { + return key; +} + + ::nebula::storage::cpp2::EdgeKey NewEdge::get_key() && { + return std::move(key); +} + +const ::std::vector& NewEdge::get_props() const& { + return props; +} + +::std::vector NewEdge::get_props() && { + return std::move(props); +} + + +void swap(NewEdge& a, NewEdge& b) { + using ::std::swap; + swap(a.key_ref().value(), b.key_ref().value()); + swap(a.props_ref().value(), b.props_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void NewEdge::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t NewEdge::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t NewEdge::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t NewEdge::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void NewEdge::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t NewEdge::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t NewEdge::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t NewEdge::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + NewEdge, + ::apache::thrift::type_class::structure, + ::nebula::storage::cpp2::EdgeKey>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + NewEdge, + ::apache::thrift::type_class::list<::apache::thrift::type_class::variant>, + ::std::vector>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + NewEdge, + ::apache::thrift::type_class::structure, + ::nebula::storage::cpp2::EdgeKey>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + NewEdge, + ::apache::thrift::type_class::list<::apache::thrift::type_class::variant>, + ::std::vector>, + "inconsistent use of nimble option"); + +}}} // nebula::storage::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::storage::cpp2::AddVerticesRequest>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::storage::cpp2::AddVerticesRequest>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace storage { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +AddVerticesRequest::AddVerticesRequest() : + space_id(0), + if_not_exists(0) {} +THRIFT_IGNORE_ISSET_USE_WARNING_END + + +AddVerticesRequest::~AddVerticesRequest() {} + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +AddVerticesRequest::AddVerticesRequest(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::storage::cpp2::NewVertex>> parts__arg, std::unordered_map< ::nebula::cpp2::TagID, ::std::vector<::std::string>> prop_names__arg, bool if_not_exists__arg, ::nebula::storage::cpp2::RequestCommon common__arg) : + space_id(std::move(space_id__arg)), + parts(std::move(parts__arg)), + prop_names(std::move(prop_names__arg)), + if_not_exists(std::move(if_not_exists__arg)), + common(std::move(common__arg)) { + __isset.space_id = true; + __isset.parts = true; + __isset.prop_names = true; + __isset.if_not_exists = true; + __isset.common = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void AddVerticesRequest::__clear() { + // clear all fields + space_id = 0; + parts.clear(); + prop_names.clear(); + if_not_exists = 0; + common.__clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool AddVerticesRequest::operator==(const AddVerticesRequest& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return false; + } + if (!(lhs.parts == rhs.parts)) { + return false; + } + if (!(lhs.prop_names == rhs.prop_names)) { + return false; + } + if (!(lhs.if_not_exists == rhs.if_not_exists)) { + return false; + } + if (lhs.common_ref() != rhs.common_ref()) { + return false; + } + return true; +} + +const std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::storage::cpp2::NewVertex>>& AddVerticesRequest::get_parts() const& { + return parts; +} + +std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::storage::cpp2::NewVertex>> AddVerticesRequest::get_parts() && { + return std::move(parts); +} + +const std::unordered_map< ::nebula::cpp2::TagID, ::std::vector<::std::string>>& AddVerticesRequest::get_prop_names() const& { + return prop_names; +} + +std::unordered_map< ::nebula::cpp2::TagID, ::std::vector<::std::string>> AddVerticesRequest::get_prop_names() && { + return std::move(prop_names); +} + +const ::nebula::storage::cpp2::RequestCommon* AddVerticesRequest::get_common() const& { + return common_ref().has_value() ? std::addressof(common) : nullptr; +} + + ::nebula::storage::cpp2::RequestCommon* AddVerticesRequest::get_common() & { + return common_ref().has_value() ? std::addressof(common) : nullptr; +} + + +void swap(AddVerticesRequest& a, AddVerticesRequest& b) { + using ::std::swap; + swap(a.space_id_ref().value(), b.space_id_ref().value()); + swap(a.parts_ref().value(), b.parts_ref().value()); + swap(a.prop_names_ref().value(), b.prop_names_ref().value()); + swap(a.if_not_exists_ref().value(), b.if_not_exists_ref().value()); + swap(a.common_ref().value_unchecked(), b.common_ref().value_unchecked()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void AddVerticesRequest::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t AddVerticesRequest::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t AddVerticesRequest::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t AddVerticesRequest::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void AddVerticesRequest::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t AddVerticesRequest::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t AddVerticesRequest::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t AddVerticesRequest::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + AddVerticesRequest, + ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>>, + std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::storage::cpp2::NewVertex>>>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + AddVerticesRequest, + ::apache::thrift::type_class::structure, + ::nebula::storage::cpp2::RequestCommon>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + AddVerticesRequest, + ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>>, + std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::storage::cpp2::NewVertex>>>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + AddVerticesRequest, + ::apache::thrift::type_class::structure, + ::nebula::storage::cpp2::RequestCommon>, + "inconsistent use of nimble option"); + +}}} // nebula::storage::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::storage::cpp2::AddEdgesRequest>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::storage::cpp2::AddEdgesRequest>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace storage { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +AddEdgesRequest::AddEdgesRequest() : + space_id(0), + if_not_exists(0) {} +THRIFT_IGNORE_ISSET_USE_WARNING_END + + +AddEdgesRequest::~AddEdgesRequest() {} + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +AddEdgesRequest::AddEdgesRequest(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::storage::cpp2::NewEdge>> parts__arg, ::std::vector<::std::string> prop_names__arg, bool if_not_exists__arg, ::nebula::storage::cpp2::RequestCommon common__arg) : + space_id(std::move(space_id__arg)), + parts(std::move(parts__arg)), + prop_names(std::move(prop_names__arg)), + if_not_exists(std::move(if_not_exists__arg)), + common(std::move(common__arg)) { + __isset.space_id = true; + __isset.parts = true; + __isset.prop_names = true; + __isset.if_not_exists = true; + __isset.common = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void AddEdgesRequest::__clear() { + // clear all fields + space_id = 0; + parts.clear(); + prop_names.clear(); + if_not_exists = 0; + common.__clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool AddEdgesRequest::operator==(const AddEdgesRequest& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return false; + } + if (!(lhs.parts == rhs.parts)) { + return false; + } + if (!(lhs.prop_names == rhs.prop_names)) { + return false; + } + if (!(lhs.if_not_exists == rhs.if_not_exists)) { + return false; + } + if (lhs.common_ref() != rhs.common_ref()) { + return false; + } + return true; +} + +const std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::storage::cpp2::NewEdge>>& AddEdgesRequest::get_parts() const& { + return parts; +} + +std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::storage::cpp2::NewEdge>> AddEdgesRequest::get_parts() && { + return std::move(parts); +} + +const ::std::vector<::std::string>& AddEdgesRequest::get_prop_names() const& { + return prop_names; +} + +::std::vector<::std::string> AddEdgesRequest::get_prop_names() && { + return std::move(prop_names); +} + +const ::nebula::storage::cpp2::RequestCommon* AddEdgesRequest::get_common() const& { + return common_ref().has_value() ? std::addressof(common) : nullptr; +} + + ::nebula::storage::cpp2::RequestCommon* AddEdgesRequest::get_common() & { + return common_ref().has_value() ? std::addressof(common) : nullptr; +} + + +void swap(AddEdgesRequest& a, AddEdgesRequest& b) { + using ::std::swap; + swap(a.space_id_ref().value(), b.space_id_ref().value()); + swap(a.parts_ref().value(), b.parts_ref().value()); + swap(a.prop_names_ref().value(), b.prop_names_ref().value()); + swap(a.if_not_exists_ref().value(), b.if_not_exists_ref().value()); + swap(a.common_ref().value_unchecked(), b.common_ref().value_unchecked()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void AddEdgesRequest::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t AddEdgesRequest::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t AddEdgesRequest::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t AddEdgesRequest::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void AddEdgesRequest::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t AddEdgesRequest::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t AddEdgesRequest::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t AddEdgesRequest::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + AddEdgesRequest, + ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>>, + std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::storage::cpp2::NewEdge>>>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + AddEdgesRequest, + ::apache::thrift::type_class::structure, + ::nebula::storage::cpp2::RequestCommon>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + AddEdgesRequest, + ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>>, + std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::storage::cpp2::NewEdge>>>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + AddEdgesRequest, + ::apache::thrift::type_class::structure, + ::nebula::storage::cpp2::RequestCommon>, + "inconsistent use of nimble option"); + +}}} // nebula::storage::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::storage::cpp2::DeleteVerticesRequest>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::storage::cpp2::DeleteVerticesRequest>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace storage { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +DeleteVerticesRequest::DeleteVerticesRequest(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector> parts__arg, ::nebula::storage::cpp2::RequestCommon common__arg) : + space_id(std::move(space_id__arg)), + parts(std::move(parts__arg)), + common(std::move(common__arg)) { + __isset.space_id = true; + __isset.parts = true; + __isset.common = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void DeleteVerticesRequest::__clear() { + // clear all fields + space_id = 0; + parts.clear(); + common.__clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool DeleteVerticesRequest::operator==(const DeleteVerticesRequest& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return false; + } + if (!(lhs.parts == rhs.parts)) { + return false; + } + if (lhs.common_ref() != rhs.common_ref()) { + return false; + } + return true; +} + +const std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector>& DeleteVerticesRequest::get_parts() const& { + return parts; +} + +std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector> DeleteVerticesRequest::get_parts() && { + return std::move(parts); +} + +const ::nebula::storage::cpp2::RequestCommon* DeleteVerticesRequest::get_common() const& { + return common_ref().has_value() ? std::addressof(common) : nullptr; +} + + ::nebula::storage::cpp2::RequestCommon* DeleteVerticesRequest::get_common() & { + return common_ref().has_value() ? std::addressof(common) : nullptr; +} + + +void swap(DeleteVerticesRequest& a, DeleteVerticesRequest& b) { + using ::std::swap; + swap(a.space_id_ref().value(), b.space_id_ref().value()); + swap(a.parts_ref().value(), b.parts_ref().value()); + swap(a.common_ref().value_unchecked(), b.common_ref().value_unchecked()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void DeleteVerticesRequest::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t DeleteVerticesRequest::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t DeleteVerticesRequest::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t DeleteVerticesRequest::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void DeleteVerticesRequest::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t DeleteVerticesRequest::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t DeleteVerticesRequest::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t DeleteVerticesRequest::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + DeleteVerticesRequest, + ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::variant>>, + std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector>>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + DeleteVerticesRequest, + ::apache::thrift::type_class::structure, + ::nebula::storage::cpp2::RequestCommon>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + DeleteVerticesRequest, + ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::variant>>, + std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector>>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + DeleteVerticesRequest, + ::apache::thrift::type_class::structure, + ::nebula::storage::cpp2::RequestCommon>, + "inconsistent use of nimble option"); + +}}} // nebula::storage::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::storage::cpp2::DeleteEdgesRequest>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::storage::cpp2::DeleteEdgesRequest>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace storage { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +DeleteEdgesRequest::DeleteEdgesRequest(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::storage::cpp2::EdgeKey>> parts__arg, ::nebula::storage::cpp2::RequestCommon common__arg) : + space_id(std::move(space_id__arg)), + parts(std::move(parts__arg)), + common(std::move(common__arg)) { + __isset.space_id = true; + __isset.parts = true; + __isset.common = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void DeleteEdgesRequest::__clear() { + // clear all fields + space_id = 0; + parts.clear(); + common.__clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool DeleteEdgesRequest::operator==(const DeleteEdgesRequest& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return false; + } + if (!(lhs.parts == rhs.parts)) { + return false; + } + if (lhs.common_ref() != rhs.common_ref()) { + return false; + } + return true; +} + +const std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::storage::cpp2::EdgeKey>>& DeleteEdgesRequest::get_parts() const& { + return parts; +} + +std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::storage::cpp2::EdgeKey>> DeleteEdgesRequest::get_parts() && { + return std::move(parts); +} + +const ::nebula::storage::cpp2::RequestCommon* DeleteEdgesRequest::get_common() const& { + return common_ref().has_value() ? std::addressof(common) : nullptr; +} + + ::nebula::storage::cpp2::RequestCommon* DeleteEdgesRequest::get_common() & { + return common_ref().has_value() ? std::addressof(common) : nullptr; +} + + +void swap(DeleteEdgesRequest& a, DeleteEdgesRequest& b) { + using ::std::swap; + swap(a.space_id_ref().value(), b.space_id_ref().value()); + swap(a.parts_ref().value(), b.parts_ref().value()); + swap(a.common_ref().value_unchecked(), b.common_ref().value_unchecked()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void DeleteEdgesRequest::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t DeleteEdgesRequest::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t DeleteEdgesRequest::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t DeleteEdgesRequest::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void DeleteEdgesRequest::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t DeleteEdgesRequest::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t DeleteEdgesRequest::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t DeleteEdgesRequest::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + DeleteEdgesRequest, + ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>>, + std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::storage::cpp2::EdgeKey>>>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + DeleteEdgesRequest, + ::apache::thrift::type_class::structure, + ::nebula::storage::cpp2::RequestCommon>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + DeleteEdgesRequest, + ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>>, + std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::storage::cpp2::EdgeKey>>>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + DeleteEdgesRequest, + ::apache::thrift::type_class::structure, + ::nebula::storage::cpp2::RequestCommon>, + "inconsistent use of nimble option"); + +}}} // nebula::storage::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::storage::cpp2::DelTags>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::storage::cpp2::DelTags>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace storage { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +DelTags::DelTags(apache::thrift::FragileConstructor, nebula::Value id__arg, ::std::vector< ::nebula::cpp2::TagID> tags__arg) : + id(std::move(id__arg)), + tags(std::move(tags__arg)) { + __isset.id = true; + __isset.tags = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void DelTags::__clear() { + // clear all fields + id.__clear(); + tags.clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool DelTags::operator==(const DelTags& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.id == rhs.id)) { + return false; + } + if (!(lhs.tags == rhs.tags)) { + return false; + } + return true; +} + +const nebula::Value& DelTags::get_id() const& { + return id; +} + +nebula::Value DelTags::get_id() && { + return std::move(id); +} + +const ::std::vector< ::nebula::cpp2::TagID>& DelTags::get_tags() const& { + return tags; +} + +::std::vector< ::nebula::cpp2::TagID> DelTags::get_tags() && { + return std::move(tags); +} + + +void swap(DelTags& a, DelTags& b) { + using ::std::swap; + swap(a.id_ref().value(), b.id_ref().value()); + swap(a.tags_ref().value(), b.tags_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void DelTags::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t DelTags::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t DelTags::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t DelTags::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void DelTags::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t DelTags::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t DelTags::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t DelTags::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + DelTags, + ::apache::thrift::type_class::variant, + nebula::Value>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + DelTags, + ::apache::thrift::type_class::variant, + nebula::Value>, + "inconsistent use of nimble option"); + +}}} // nebula::storage::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::storage::cpp2::DeleteTagsRequest>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::storage::cpp2::DeleteTagsRequest>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace storage { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +DeleteTagsRequest::DeleteTagsRequest(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::storage::cpp2::DelTags>> parts__arg, ::nebula::storage::cpp2::RequestCommon common__arg) : + space_id(std::move(space_id__arg)), + parts(std::move(parts__arg)), + common(std::move(common__arg)) { + __isset.space_id = true; + __isset.parts = true; + __isset.common = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void DeleteTagsRequest::__clear() { + // clear all fields + space_id = 0; + parts.clear(); + common.__clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool DeleteTagsRequest::operator==(const DeleteTagsRequest& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return false; + } + if (!(lhs.parts == rhs.parts)) { + return false; + } + if (lhs.common_ref() != rhs.common_ref()) { + return false; + } + return true; +} + +const std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::storage::cpp2::DelTags>>& DeleteTagsRequest::get_parts() const& { + return parts; +} + +std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::storage::cpp2::DelTags>> DeleteTagsRequest::get_parts() && { + return std::move(parts); +} + +const ::nebula::storage::cpp2::RequestCommon* DeleteTagsRequest::get_common() const& { + return common_ref().has_value() ? std::addressof(common) : nullptr; +} + + ::nebula::storage::cpp2::RequestCommon* DeleteTagsRequest::get_common() & { + return common_ref().has_value() ? std::addressof(common) : nullptr; +} + + +void swap(DeleteTagsRequest& a, DeleteTagsRequest& b) { + using ::std::swap; + swap(a.space_id_ref().value(), b.space_id_ref().value()); + swap(a.parts_ref().value(), b.parts_ref().value()); + swap(a.common_ref().value_unchecked(), b.common_ref().value_unchecked()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void DeleteTagsRequest::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t DeleteTagsRequest::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t DeleteTagsRequest::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t DeleteTagsRequest::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void DeleteTagsRequest::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t DeleteTagsRequest::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t DeleteTagsRequest::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t DeleteTagsRequest::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + DeleteTagsRequest, + ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>>, + std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::storage::cpp2::DelTags>>>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + DeleteTagsRequest, + ::apache::thrift::type_class::structure, + ::nebula::storage::cpp2::RequestCommon>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + DeleteTagsRequest, + ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>>, + std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::storage::cpp2::DelTags>>>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + DeleteTagsRequest, + ::apache::thrift::type_class::structure, + ::nebula::storage::cpp2::RequestCommon>, + "inconsistent use of nimble option"); + +}}} // nebula::storage::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::storage::cpp2::UpdateResponse>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::storage::cpp2::UpdateResponse>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace storage { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +UpdateResponse::UpdateResponse(apache::thrift::FragileConstructor, ::nebula::storage::cpp2::ResponseCommon result__arg, nebula::DataSet props__arg) : + result(std::move(result__arg)), + props(std::move(props__arg)) { + __isset.props = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void UpdateResponse::__clear() { + // clear all fields + result.__clear(); + props.__clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool UpdateResponse::operator==(const UpdateResponse& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.result == rhs.result)) { + return false; + } + if (lhs.props_ref() != rhs.props_ref()) { + return false; + } + return true; +} + +const ::nebula::storage::cpp2::ResponseCommon& UpdateResponse::get_result() const& { + return result; +} + + ::nebula::storage::cpp2::ResponseCommon UpdateResponse::get_result() && { + return std::move(result); +} + +const nebula::DataSet* UpdateResponse::get_props() const& { + return props_ref().has_value() ? std::addressof(props) : nullptr; +} + +nebula::DataSet* UpdateResponse::get_props() & { + return props_ref().has_value() ? std::addressof(props) : nullptr; +} + + +void swap(UpdateResponse& a, UpdateResponse& b) { + using ::std::swap; + swap(a.result_ref().value(), b.result_ref().value()); + swap(a.props_ref().value_unchecked(), b.props_ref().value_unchecked()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void UpdateResponse::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t UpdateResponse::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t UpdateResponse::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t UpdateResponse::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void UpdateResponse::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t UpdateResponse::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t UpdateResponse::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t UpdateResponse::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + UpdateResponse, + ::apache::thrift::type_class::structure, + ::nebula::storage::cpp2::ResponseCommon>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + UpdateResponse, + ::apache::thrift::type_class::structure, + nebula::DataSet>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + UpdateResponse, + ::apache::thrift::type_class::structure, + ::nebula::storage::cpp2::ResponseCommon>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + UpdateResponse, + ::apache::thrift::type_class::structure, + nebula::DataSet>, + "inconsistent use of nimble option"); + +}}} // nebula::storage::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::storage::cpp2::UpdatedProp>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::storage::cpp2::UpdatedProp>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace storage { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +UpdatedProp::UpdatedProp(apache::thrift::FragileConstructor, ::std::string name__arg, ::std::string value__arg) : + name(std::move(name__arg)), + value(std::move(value__arg)) {} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void UpdatedProp::__clear() { + // clear all fields + name = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); + value = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); +} + +bool UpdatedProp::operator==(const UpdatedProp& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!apache::thrift::StringTraits::isEqual(lhs.name, rhs.name)) { + return false; + } + if (!apache::thrift::StringTraits::isEqual(lhs.value, rhs.value)) { + return false; + } + return true; +} + +bool UpdatedProp::operator<(const UpdatedProp& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!apache::thrift::StringTraits::isEqual(lhs.name, rhs.name)) { + return apache::thrift::StringTraits::isLess(lhs.name, rhs.name); + } + if (!apache::thrift::StringTraits::isEqual(lhs.value, rhs.value)) { + return apache::thrift::StringTraits::isLess(lhs.value, rhs.value); + } + return false; +} + + +void swap(UpdatedProp& a, UpdatedProp& b) { + using ::std::swap; + swap(a.name_ref().value(), b.name_ref().value()); + swap(a.value_ref().value(), b.value_ref().value()); +} + +template void UpdatedProp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t UpdatedProp::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t UpdatedProp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t UpdatedProp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void UpdatedProp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t UpdatedProp::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t UpdatedProp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t UpdatedProp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::storage::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::storage::cpp2::UpdateVertexRequest>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::storage::cpp2::UpdateVertexRequest>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace storage { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +UpdateVertexRequest::UpdateVertexRequest() : + space_id(0), + part_id(0), + tag_id(0), + insertable(false) {} +THRIFT_IGNORE_ISSET_USE_WARNING_END + + +UpdateVertexRequest::~UpdateVertexRequest() {} + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +UpdateVertexRequest::UpdateVertexRequest(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, ::nebula::cpp2::PartitionID part_id__arg, nebula::Value vertex_id__arg, ::nebula::cpp2::TagID tag_id__arg, ::std::vector< ::nebula::storage::cpp2::UpdatedProp> updated_props__arg, bool insertable__arg, ::std::vector<::std::string> return_props__arg, ::std::string condition__arg, ::nebula::storage::cpp2::RequestCommon common__arg) : + space_id(std::move(space_id__arg)), + part_id(std::move(part_id__arg)), + vertex_id(std::move(vertex_id__arg)), + tag_id(std::move(tag_id__arg)), + updated_props(std::move(updated_props__arg)), + insertable(std::move(insertable__arg)), + return_props(std::move(return_props__arg)), + condition(std::move(condition__arg)), + common(std::move(common__arg)) { + __isset.space_id = true; + __isset.part_id = true; + __isset.vertex_id = true; + __isset.updated_props = true; + __isset.insertable = true; + __isset.return_props = true; + __isset.condition = true; + __isset.common = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void UpdateVertexRequest::__clear() { + // clear all fields + space_id = 0; + part_id = 0; + vertex_id.__clear(); + tag_id = 0; + updated_props.clear(); + insertable = false; + return_props.clear(); + condition = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); + common.__clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool UpdateVertexRequest::operator==(const UpdateVertexRequest& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return false; + } + if (!(lhs.part_id == rhs.part_id)) { + return false; + } + if (!(lhs.vertex_id == rhs.vertex_id)) { + return false; + } + if (!(lhs.tag_id == rhs.tag_id)) { + return false; + } + if (!(lhs.updated_props == rhs.updated_props)) { + return false; + } + if (lhs.insertable_ref() != rhs.insertable_ref()) { + return false; + } + if (lhs.return_props_ref() != rhs.return_props_ref()) { + return false; + } + if (lhs.condition_ref().has_value() != rhs.condition_ref().has_value()) { + return false; + } + if (lhs.condition_ref().has_value()) { + if (!apache::thrift::StringTraits::isEqual(lhs.condition, rhs.condition)) { + return false; + } + } + if (lhs.common_ref() != rhs.common_ref()) { + return false; + } + return true; +} + +const nebula::Value& UpdateVertexRequest::get_vertex_id() const& { + return vertex_id; +} + +nebula::Value UpdateVertexRequest::get_vertex_id() && { + return std::move(vertex_id); +} + +const ::std::vector< ::nebula::storage::cpp2::UpdatedProp>& UpdateVertexRequest::get_updated_props() const& { + return updated_props; +} + +::std::vector< ::nebula::storage::cpp2::UpdatedProp> UpdateVertexRequest::get_updated_props() && { + return std::move(updated_props); +} + +const ::std::vector<::std::string>* UpdateVertexRequest::get_return_props() const& { + return return_props_ref().has_value() ? std::addressof(return_props) : nullptr; +} + +::std::vector<::std::string>* UpdateVertexRequest::get_return_props() & { + return return_props_ref().has_value() ? std::addressof(return_props) : nullptr; +} + +const ::nebula::storage::cpp2::RequestCommon* UpdateVertexRequest::get_common() const& { + return common_ref().has_value() ? std::addressof(common) : nullptr; +} + + ::nebula::storage::cpp2::RequestCommon* UpdateVertexRequest::get_common() & { + return common_ref().has_value() ? std::addressof(common) : nullptr; +} + + +void swap(UpdateVertexRequest& a, UpdateVertexRequest& b) { + using ::std::swap; + swap(a.space_id_ref().value(), b.space_id_ref().value()); + swap(a.part_id_ref().value(), b.part_id_ref().value()); + swap(a.vertex_id_ref().value(), b.vertex_id_ref().value()); + swap(a.tag_id_ref().value(), b.tag_id_ref().value()); + swap(a.updated_props_ref().value(), b.updated_props_ref().value()); + swap(a.insertable_ref().value_unchecked(), b.insertable_ref().value_unchecked()); + swap(a.return_props_ref().value_unchecked(), b.return_props_ref().value_unchecked()); + swap(a.condition_ref().value_unchecked(), b.condition_ref().value_unchecked()); + swap(a.common_ref().value_unchecked(), b.common_ref().value_unchecked()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void UpdateVertexRequest::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t UpdateVertexRequest::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t UpdateVertexRequest::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t UpdateVertexRequest::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void UpdateVertexRequest::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t UpdateVertexRequest::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t UpdateVertexRequest::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t UpdateVertexRequest::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + UpdateVertexRequest, + ::apache::thrift::type_class::variant, + nebula::Value>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + UpdateVertexRequest, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector< ::nebula::storage::cpp2::UpdatedProp>>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + UpdateVertexRequest, + ::apache::thrift::type_class::structure, + ::nebula::storage::cpp2::RequestCommon>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + UpdateVertexRequest, + ::apache::thrift::type_class::variant, + nebula::Value>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + UpdateVertexRequest, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector< ::nebula::storage::cpp2::UpdatedProp>>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + UpdateVertexRequest, + ::apache::thrift::type_class::structure, + ::nebula::storage::cpp2::RequestCommon>, + "inconsistent use of nimble option"); + +}}} // nebula::storage::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::storage::cpp2::UpdateEdgeRequest>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::storage::cpp2::UpdateEdgeRequest>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace storage { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +UpdateEdgeRequest::UpdateEdgeRequest() : + space_id(0), + part_id(0), + insertable(false) {} +THRIFT_IGNORE_ISSET_USE_WARNING_END + + +UpdateEdgeRequest::~UpdateEdgeRequest() {} + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +UpdateEdgeRequest::UpdateEdgeRequest(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, ::nebula::cpp2::PartitionID part_id__arg, ::nebula::storage::cpp2::EdgeKey edge_key__arg, ::std::vector< ::nebula::storage::cpp2::UpdatedProp> updated_props__arg, bool insertable__arg, ::std::vector<::std::string> return_props__arg, ::std::string condition__arg, ::nebula::storage::cpp2::RequestCommon common__arg) : + space_id(std::move(space_id__arg)), + part_id(std::move(part_id__arg)), + edge_key(std::move(edge_key__arg)), + updated_props(std::move(updated_props__arg)), + insertable(std::move(insertable__arg)), + return_props(std::move(return_props__arg)), + condition(std::move(condition__arg)), + common(std::move(common__arg)) { + __isset.space_id = true; + __isset.part_id = true; + __isset.edge_key = true; + __isset.updated_props = true; + __isset.insertable = true; + __isset.return_props = true; + __isset.condition = true; + __isset.common = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void UpdateEdgeRequest::__clear() { + // clear all fields + space_id = 0; + part_id = 0; + edge_key.__clear(); + updated_props.clear(); + insertable = false; + return_props.clear(); + condition = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); + common.__clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool UpdateEdgeRequest::operator==(const UpdateEdgeRequest& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return false; + } + if (!(lhs.part_id == rhs.part_id)) { + return false; + } + if (!(lhs.edge_key == rhs.edge_key)) { + return false; + } + if (!(lhs.updated_props == rhs.updated_props)) { + return false; + } + if (lhs.insertable_ref() != rhs.insertable_ref()) { + return false; + } + if (lhs.return_props_ref() != rhs.return_props_ref()) { + return false; + } + if (lhs.condition_ref().has_value() != rhs.condition_ref().has_value()) { + return false; + } + if (lhs.condition_ref().has_value()) { + if (!apache::thrift::StringTraits::isEqual(lhs.condition, rhs.condition)) { + return false; + } + } + if (lhs.common_ref() != rhs.common_ref()) { + return false; + } + return true; +} + +const ::nebula::storage::cpp2::EdgeKey& UpdateEdgeRequest::get_edge_key() const& { + return edge_key; +} + + ::nebula::storage::cpp2::EdgeKey UpdateEdgeRequest::get_edge_key() && { + return std::move(edge_key); +} + +const ::std::vector< ::nebula::storage::cpp2::UpdatedProp>& UpdateEdgeRequest::get_updated_props() const& { + return updated_props; +} + +::std::vector< ::nebula::storage::cpp2::UpdatedProp> UpdateEdgeRequest::get_updated_props() && { + return std::move(updated_props); +} + +const ::std::vector<::std::string>* UpdateEdgeRequest::get_return_props() const& { + return return_props_ref().has_value() ? std::addressof(return_props) : nullptr; +} + +::std::vector<::std::string>* UpdateEdgeRequest::get_return_props() & { + return return_props_ref().has_value() ? std::addressof(return_props) : nullptr; +} + +const ::nebula::storage::cpp2::RequestCommon* UpdateEdgeRequest::get_common() const& { + return common_ref().has_value() ? std::addressof(common) : nullptr; +} + + ::nebula::storage::cpp2::RequestCommon* UpdateEdgeRequest::get_common() & { + return common_ref().has_value() ? std::addressof(common) : nullptr; +} + + +void swap(UpdateEdgeRequest& a, UpdateEdgeRequest& b) { + using ::std::swap; + swap(a.space_id_ref().value(), b.space_id_ref().value()); + swap(a.part_id_ref().value(), b.part_id_ref().value()); + swap(a.edge_key_ref().value(), b.edge_key_ref().value()); + swap(a.updated_props_ref().value(), b.updated_props_ref().value()); + swap(a.insertable_ref().value_unchecked(), b.insertable_ref().value_unchecked()); + swap(a.return_props_ref().value_unchecked(), b.return_props_ref().value_unchecked()); + swap(a.condition_ref().value_unchecked(), b.condition_ref().value_unchecked()); + swap(a.common_ref().value_unchecked(), b.common_ref().value_unchecked()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void UpdateEdgeRequest::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t UpdateEdgeRequest::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t UpdateEdgeRequest::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t UpdateEdgeRequest::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void UpdateEdgeRequest::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t UpdateEdgeRequest::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t UpdateEdgeRequest::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t UpdateEdgeRequest::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + UpdateEdgeRequest, + ::apache::thrift::type_class::structure, + ::nebula::storage::cpp2::EdgeKey>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + UpdateEdgeRequest, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector< ::nebula::storage::cpp2::UpdatedProp>>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + UpdateEdgeRequest, + ::apache::thrift::type_class::structure, + ::nebula::storage::cpp2::RequestCommon>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + UpdateEdgeRequest, + ::apache::thrift::type_class::structure, + ::nebula::storage::cpp2::EdgeKey>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + UpdateEdgeRequest, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector< ::nebula::storage::cpp2::UpdatedProp>>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + UpdateEdgeRequest, + ::apache::thrift::type_class::structure, + ::nebula::storage::cpp2::RequestCommon>, + "inconsistent use of nimble option"); + +}}} // nebula::storage::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::storage::cpp2::GetUUIDReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::storage::cpp2::GetUUIDReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace storage { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +GetUUIDReq::GetUUIDReq(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, ::nebula::cpp2::PartitionID part_id__arg, ::std::string name__arg, ::nebula::storage::cpp2::RequestCommon common__arg) : + space_id(std::move(space_id__arg)), + part_id(std::move(part_id__arg)), + name(std::move(name__arg)), + common(std::move(common__arg)) { + __isset.space_id = true; + __isset.part_id = true; + __isset.name = true; + __isset.common = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void GetUUIDReq::__clear() { + // clear all fields + space_id = 0; + part_id = 0; + name = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); + common.__clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool GetUUIDReq::operator==(const GetUUIDReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return false; + } + if (!(lhs.part_id == rhs.part_id)) { + return false; + } + if (!apache::thrift::StringTraits::isEqual(lhs.name, rhs.name)) { + return false; + } + if (lhs.common_ref() != rhs.common_ref()) { + return false; + } + return true; +} + +bool GetUUIDReq::operator<(const GetUUIDReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return lhs.space_id < rhs.space_id; + } + if (!(lhs.part_id == rhs.part_id)) { + return lhs.part_id < rhs.part_id; + } + if (!apache::thrift::StringTraits::isEqual(lhs.name, rhs.name)) { + return apache::thrift::StringTraits::isLess(lhs.name, rhs.name); + } + if (lhs.common_ref() != rhs.common_ref()) { + return lhs.common_ref() < rhs.common_ref(); + } + return false; +} + +const ::nebula::storage::cpp2::RequestCommon* GetUUIDReq::get_common() const& { + return common_ref().has_value() ? std::addressof(common) : nullptr; +} + + ::nebula::storage::cpp2::RequestCommon* GetUUIDReq::get_common() & { + return common_ref().has_value() ? std::addressof(common) : nullptr; +} + + +void swap(GetUUIDReq& a, GetUUIDReq& b) { + using ::std::swap; + swap(a.space_id_ref().value(), b.space_id_ref().value()); + swap(a.part_id_ref().value(), b.part_id_ref().value()); + swap(a.name_ref().value(), b.name_ref().value()); + swap(a.common_ref().value_unchecked(), b.common_ref().value_unchecked()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void GetUUIDReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t GetUUIDReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t GetUUIDReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t GetUUIDReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void GetUUIDReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t GetUUIDReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t GetUUIDReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t GetUUIDReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + GetUUIDReq, + ::apache::thrift::type_class::structure, + ::nebula::storage::cpp2::RequestCommon>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + GetUUIDReq, + ::apache::thrift::type_class::structure, + ::nebula::storage::cpp2::RequestCommon>, + "inconsistent use of nimble option"); + +}}} // nebula::storage::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::storage::cpp2::GetUUIDResp>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::storage::cpp2::GetUUIDResp>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace storage { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +GetUUIDResp::GetUUIDResp(apache::thrift::FragileConstructor, ::nebula::storage::cpp2::ResponseCommon result__arg, nebula::Value id__arg) : + result(std::move(result__arg)), + id(std::move(id__arg)) { + __isset.id = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void GetUUIDResp::__clear() { + // clear all fields + result.__clear(); + id.__clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool GetUUIDResp::operator==(const GetUUIDResp& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.result == rhs.result)) { + return false; + } + if (!(lhs.id == rhs.id)) { + return false; + } + return true; +} + +const ::nebula::storage::cpp2::ResponseCommon& GetUUIDResp::get_result() const& { + return result; +} + + ::nebula::storage::cpp2::ResponseCommon GetUUIDResp::get_result() && { + return std::move(result); +} + +const nebula::Value& GetUUIDResp::get_id() const& { + return id; +} + +nebula::Value GetUUIDResp::get_id() && { + return std::move(id); +} + + +void swap(GetUUIDResp& a, GetUUIDResp& b) { + using ::std::swap; + swap(a.result_ref().value(), b.result_ref().value()); + swap(a.id_ref().value(), b.id_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void GetUUIDResp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t GetUUIDResp::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t GetUUIDResp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t GetUUIDResp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void GetUUIDResp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t GetUUIDResp::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t GetUUIDResp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t GetUUIDResp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + GetUUIDResp, + ::apache::thrift::type_class::structure, + ::nebula::storage::cpp2::ResponseCommon>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + GetUUIDResp, + ::apache::thrift::type_class::variant, + nebula::Value>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + GetUUIDResp, + ::apache::thrift::type_class::structure, + ::nebula::storage::cpp2::ResponseCommon>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + GetUUIDResp, + ::apache::thrift::type_class::variant, + nebula::Value>, + "inconsistent use of nimble option"); + +}}} // nebula::storage::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::storage::cpp2::LookupIndexResp>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::storage::cpp2::LookupIndexResp>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace storage { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +LookupIndexResp::LookupIndexResp(apache::thrift::FragileConstructor, ::nebula::storage::cpp2::ResponseCommon result__arg, nebula::DataSet data__arg) : + result(std::move(result__arg)), + data(std::move(data__arg)) { + __isset.data = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void LookupIndexResp::__clear() { + // clear all fields + result.__clear(); + data.__clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool LookupIndexResp::operator==(const LookupIndexResp& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.result == rhs.result)) { + return false; + } + if (lhs.data_ref() != rhs.data_ref()) { + return false; + } + return true; +} + +const ::nebula::storage::cpp2::ResponseCommon& LookupIndexResp::get_result() const& { + return result; +} + + ::nebula::storage::cpp2::ResponseCommon LookupIndexResp::get_result() && { + return std::move(result); +} + +const nebula::DataSet* LookupIndexResp::get_data() const& { + return data_ref().has_value() ? std::addressof(data) : nullptr; +} + +nebula::DataSet* LookupIndexResp::get_data() & { + return data_ref().has_value() ? std::addressof(data) : nullptr; +} + + +void swap(LookupIndexResp& a, LookupIndexResp& b) { + using ::std::swap; + swap(a.result_ref().value(), b.result_ref().value()); + swap(a.data_ref().value_unchecked(), b.data_ref().value_unchecked()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void LookupIndexResp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t LookupIndexResp::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t LookupIndexResp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t LookupIndexResp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void LookupIndexResp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t LookupIndexResp::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t LookupIndexResp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t LookupIndexResp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + LookupIndexResp, + ::apache::thrift::type_class::structure, + ::nebula::storage::cpp2::ResponseCommon>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + LookupIndexResp, + ::apache::thrift::type_class::structure, + nebula::DataSet>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + LookupIndexResp, + ::apache::thrift::type_class::structure, + ::nebula::storage::cpp2::ResponseCommon>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + LookupIndexResp, + ::apache::thrift::type_class::structure, + nebula::DataSet>, + "inconsistent use of nimble option"); + +}}} // nebula::storage::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::storage::cpp2::IndexColumnHint>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::storage::cpp2::IndexColumnHint>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace storage { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +IndexColumnHint::IndexColumnHint(apache::thrift::FragileConstructor, ::std::string column_name__arg, ::nebula::storage::cpp2::ScanType scan_type__arg, nebula::Value begin_value__arg, nebula::Value end_value__arg) : + column_name(std::move(column_name__arg)), + scan_type(std::move(scan_type__arg)), + begin_value(std::move(begin_value__arg)), + end_value(std::move(end_value__arg)) { + __isset.column_name = true; + __isset.scan_type = true; + __isset.begin_value = true; + __isset.end_value = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void IndexColumnHint::__clear() { + // clear all fields + column_name = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); + scan_type = static_cast< ::nebula::storage::cpp2::ScanType>(0); + begin_value.__clear(); + end_value.__clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool IndexColumnHint::operator==(const IndexColumnHint& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!apache::thrift::StringTraits::isEqual(lhs.column_name, rhs.column_name)) { + return false; + } + if (!(lhs.scan_type == rhs.scan_type)) { + return false; + } + if (!(lhs.begin_value == rhs.begin_value)) { + return false; + } + if (!(lhs.end_value == rhs.end_value)) { + return false; + } + return true; +} + +const nebula::Value& IndexColumnHint::get_begin_value() const& { + return begin_value; +} + +nebula::Value IndexColumnHint::get_begin_value() && { + return std::move(begin_value); +} + +const nebula::Value& IndexColumnHint::get_end_value() const& { + return end_value; +} + +nebula::Value IndexColumnHint::get_end_value() && { + return std::move(end_value); +} + + +void swap(IndexColumnHint& a, IndexColumnHint& b) { + using ::std::swap; + swap(a.column_name_ref().value(), b.column_name_ref().value()); + swap(a.scan_type_ref().value(), b.scan_type_ref().value()); + swap(a.begin_value_ref().value(), b.begin_value_ref().value()); + swap(a.end_value_ref().value(), b.end_value_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void IndexColumnHint::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t IndexColumnHint::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t IndexColumnHint::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t IndexColumnHint::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void IndexColumnHint::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t IndexColumnHint::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t IndexColumnHint::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t IndexColumnHint::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + IndexColumnHint, + ::apache::thrift::type_class::variant, + nebula::Value>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + IndexColumnHint, + ::apache::thrift::type_class::variant, + nebula::Value>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + IndexColumnHint, + ::apache::thrift::type_class::variant, + nebula::Value>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + IndexColumnHint, + ::apache::thrift::type_class::variant, + nebula::Value>, + "inconsistent use of nimble option"); + +}}} // nebula::storage::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::storage::cpp2::IndexQueryContext>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::storage::cpp2::IndexQueryContext>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace storage { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +IndexQueryContext::IndexQueryContext(apache::thrift::FragileConstructor, ::nebula::cpp2::IndexID index_id__arg, ::std::string filter__arg, ::std::vector< ::nebula::storage::cpp2::IndexColumnHint> column_hints__arg) : + index_id(std::move(index_id__arg)), + filter(std::move(filter__arg)), + column_hints(std::move(column_hints__arg)) { + __isset.index_id = true; + __isset.filter = true; + __isset.column_hints = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void IndexQueryContext::__clear() { + // clear all fields + index_id = 0; + filter = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); + column_hints.clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool IndexQueryContext::operator==(const IndexQueryContext& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.index_id == rhs.index_id)) { + return false; + } + if (!apache::thrift::StringTraits::isEqual(lhs.filter, rhs.filter)) { + return false; + } + if (!(lhs.column_hints == rhs.column_hints)) { + return false; + } + return true; +} + +const ::std::vector< ::nebula::storage::cpp2::IndexColumnHint>& IndexQueryContext::get_column_hints() const& { + return column_hints; +} + +::std::vector< ::nebula::storage::cpp2::IndexColumnHint> IndexQueryContext::get_column_hints() && { + return std::move(column_hints); +} + + +void swap(IndexQueryContext& a, IndexQueryContext& b) { + using ::std::swap; + swap(a.index_id_ref().value(), b.index_id_ref().value()); + swap(a.filter_ref().value(), b.filter_ref().value()); + swap(a.column_hints_ref().value(), b.column_hints_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void IndexQueryContext::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t IndexQueryContext::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t IndexQueryContext::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t IndexQueryContext::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void IndexQueryContext::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t IndexQueryContext::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t IndexQueryContext::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t IndexQueryContext::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + IndexQueryContext, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector< ::nebula::storage::cpp2::IndexColumnHint>>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + IndexQueryContext, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector< ::nebula::storage::cpp2::IndexColumnHint>>, + "inconsistent use of nimble option"); + +}}} // nebula::storage::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::storage::cpp2::IndexSpec>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::storage::cpp2::IndexSpec>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace storage { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +IndexSpec::IndexSpec(apache::thrift::FragileConstructor, ::std::vector< ::nebula::storage::cpp2::IndexQueryContext> contexts__arg, ::nebula::cpp2::SchemaID schema_id__arg) : + contexts(std::move(contexts__arg)), + schema_id(std::move(schema_id__arg)) { + __isset.schema_id = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void IndexSpec::__clear() { + // clear all fields + contexts.clear(); + schema_id.__clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool IndexSpec::operator==(const IndexSpec& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.contexts == rhs.contexts)) { + return false; + } + if (!(lhs.schema_id == rhs.schema_id)) { + return false; + } + return true; +} + +const ::std::vector< ::nebula::storage::cpp2::IndexQueryContext>& IndexSpec::get_contexts() const& { + return contexts; +} + +::std::vector< ::nebula::storage::cpp2::IndexQueryContext> IndexSpec::get_contexts() && { + return std::move(contexts); +} + +const ::nebula::cpp2::SchemaID& IndexSpec::get_schema_id() const& { + return schema_id; +} + + ::nebula::cpp2::SchemaID IndexSpec::get_schema_id() && { + return std::move(schema_id); +} + + +void swap(IndexSpec& a, IndexSpec& b) { + using ::std::swap; + swap(a.contexts_ref().value(), b.contexts_ref().value()); + swap(a.schema_id_ref().value(), b.schema_id_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void IndexSpec::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t IndexSpec::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t IndexSpec::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t IndexSpec::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void IndexSpec::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t IndexSpec::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t IndexSpec::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t IndexSpec::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + IndexSpec, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector< ::nebula::storage::cpp2::IndexQueryContext>>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + IndexSpec, + ::apache::thrift::type_class::variant, + ::nebula::cpp2::SchemaID>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + IndexSpec, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector< ::nebula::storage::cpp2::IndexQueryContext>>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + IndexSpec, + ::apache::thrift::type_class::variant, + ::nebula::cpp2::SchemaID>, + "inconsistent use of nimble option"); + +}}} // nebula::storage::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::storage::cpp2::LookupIndexRequest>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::storage::cpp2::LookupIndexRequest>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace storage { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +LookupIndexRequest::LookupIndexRequest() : + space_id(0), + limit(0) {} +THRIFT_IGNORE_ISSET_USE_WARNING_END + + +LookupIndexRequest::~LookupIndexRequest() {} + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +LookupIndexRequest::LookupIndexRequest(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, ::std::vector< ::nebula::cpp2::PartitionID> parts__arg, ::nebula::storage::cpp2::IndexSpec indices__arg, ::std::vector<::std::string> return_columns__arg, ::nebula::storage::cpp2::RequestCommon common__arg, int64_t limit__arg) : + space_id(std::move(space_id__arg)), + parts(std::move(parts__arg)), + indices(std::move(indices__arg)), + return_columns(std::move(return_columns__arg)), + common(std::move(common__arg)), + limit(std::move(limit__arg)) { + __isset.indices = true; + __isset.return_columns = true; + __isset.common = true; + __isset.limit = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void LookupIndexRequest::__clear() { + // clear all fields + space_id = 0; + parts.clear(); + indices.__clear(); + return_columns.clear(); + common.__clear(); + limit = 0; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool LookupIndexRequest::operator==(const LookupIndexRequest& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return false; + } + if (!(lhs.parts == rhs.parts)) { + return false; + } + if (!(lhs.indices == rhs.indices)) { + return false; + } + if (lhs.return_columns_ref() != rhs.return_columns_ref()) { + return false; + } + if (lhs.common_ref() != rhs.common_ref()) { + return false; + } + if (lhs.limit_ref() != rhs.limit_ref()) { + return false; + } + return true; +} + +const ::std::vector< ::nebula::cpp2::PartitionID>& LookupIndexRequest::get_parts() const& { + return parts; +} + +::std::vector< ::nebula::cpp2::PartitionID> LookupIndexRequest::get_parts() && { + return std::move(parts); +} + +const ::nebula::storage::cpp2::IndexSpec& LookupIndexRequest::get_indices() const& { + return indices; +} + + ::nebula::storage::cpp2::IndexSpec LookupIndexRequest::get_indices() && { + return std::move(indices); +} + +const ::std::vector<::std::string>* LookupIndexRequest::get_return_columns() const& { + return return_columns_ref().has_value() ? std::addressof(return_columns) : nullptr; +} + +::std::vector<::std::string>* LookupIndexRequest::get_return_columns() & { + return return_columns_ref().has_value() ? std::addressof(return_columns) : nullptr; +} + +const ::nebula::storage::cpp2::RequestCommon* LookupIndexRequest::get_common() const& { + return common_ref().has_value() ? std::addressof(common) : nullptr; +} + + ::nebula::storage::cpp2::RequestCommon* LookupIndexRequest::get_common() & { + return common_ref().has_value() ? std::addressof(common) : nullptr; +} + + +void swap(LookupIndexRequest& a, LookupIndexRequest& b) { + using ::std::swap; + swap(a.space_id_ref().value(), b.space_id_ref().value()); + swap(a.parts_ref().value(), b.parts_ref().value()); + swap(a.indices_ref().value(), b.indices_ref().value()); + swap(a.return_columns_ref().value_unchecked(), b.return_columns_ref().value_unchecked()); + swap(a.common_ref().value_unchecked(), b.common_ref().value_unchecked()); + swap(a.limit_ref().value_unchecked(), b.limit_ref().value_unchecked()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void LookupIndexRequest::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t LookupIndexRequest::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t LookupIndexRequest::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t LookupIndexRequest::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void LookupIndexRequest::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t LookupIndexRequest::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t LookupIndexRequest::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t LookupIndexRequest::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + LookupIndexRequest, + ::apache::thrift::type_class::structure, + ::nebula::storage::cpp2::IndexSpec>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + LookupIndexRequest, + ::apache::thrift::type_class::structure, + ::nebula::storage::cpp2::RequestCommon>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + LookupIndexRequest, + ::apache::thrift::type_class::structure, + ::nebula::storage::cpp2::IndexSpec>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + LookupIndexRequest, + ::apache::thrift::type_class::structure, + ::nebula::storage::cpp2::RequestCommon>, + "inconsistent use of nimble option"); + +}}} // nebula::storage::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::storage::cpp2::LookupAndTraverseRequest>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::storage::cpp2::LookupAndTraverseRequest>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace storage { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +LookupAndTraverseRequest::LookupAndTraverseRequest() : + space_id(0) {} +THRIFT_IGNORE_ISSET_USE_WARNING_END + + +LookupAndTraverseRequest::~LookupAndTraverseRequest() {} + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +LookupAndTraverseRequest::LookupAndTraverseRequest(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, ::std::vector< ::nebula::cpp2::PartitionID> parts__arg, ::nebula::storage::cpp2::IndexSpec indices__arg, ::nebula::storage::cpp2::TraverseSpec traverse_spec__arg, ::nebula::storage::cpp2::RequestCommon common__arg) : + space_id(std::move(space_id__arg)), + parts(std::move(parts__arg)), + indices(std::move(indices__arg)), + traverse_spec(std::move(traverse_spec__arg)), + common(std::move(common__arg)) { + __isset.indices = true; + __isset.traverse_spec = true; + __isset.common = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void LookupAndTraverseRequest::__clear() { + // clear all fields + space_id = 0; + parts.clear(); + indices.__clear(); + traverse_spec.__clear(); + common.__clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool LookupAndTraverseRequest::operator==(const LookupAndTraverseRequest& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return false; + } + if (!(lhs.parts == rhs.parts)) { + return false; + } + if (!(lhs.indices == rhs.indices)) { + return false; + } + if (!(lhs.traverse_spec == rhs.traverse_spec)) { + return false; + } + if (lhs.common_ref() != rhs.common_ref()) { + return false; + } + return true; +} + +const ::std::vector< ::nebula::cpp2::PartitionID>& LookupAndTraverseRequest::get_parts() const& { + return parts; +} + +::std::vector< ::nebula::cpp2::PartitionID> LookupAndTraverseRequest::get_parts() && { + return std::move(parts); +} + +const ::nebula::storage::cpp2::IndexSpec& LookupAndTraverseRequest::get_indices() const& { + return indices; +} + + ::nebula::storage::cpp2::IndexSpec LookupAndTraverseRequest::get_indices() && { + return std::move(indices); +} + +const ::nebula::storage::cpp2::TraverseSpec& LookupAndTraverseRequest::get_traverse_spec() const& { + return traverse_spec; +} + + ::nebula::storage::cpp2::TraverseSpec LookupAndTraverseRequest::get_traverse_spec() && { + return std::move(traverse_spec); +} + +const ::nebula::storage::cpp2::RequestCommon* LookupAndTraverseRequest::get_common() const& { + return common_ref().has_value() ? std::addressof(common) : nullptr; +} + + ::nebula::storage::cpp2::RequestCommon* LookupAndTraverseRequest::get_common() & { + return common_ref().has_value() ? std::addressof(common) : nullptr; +} + + +void swap(LookupAndTraverseRequest& a, LookupAndTraverseRequest& b) { + using ::std::swap; + swap(a.space_id_ref().value(), b.space_id_ref().value()); + swap(a.parts_ref().value(), b.parts_ref().value()); + swap(a.indices_ref().value(), b.indices_ref().value()); + swap(a.traverse_spec_ref().value(), b.traverse_spec_ref().value()); + swap(a.common_ref().value_unchecked(), b.common_ref().value_unchecked()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void LookupAndTraverseRequest::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t LookupAndTraverseRequest::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t LookupAndTraverseRequest::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t LookupAndTraverseRequest::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void LookupAndTraverseRequest::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t LookupAndTraverseRequest::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t LookupAndTraverseRequest::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t LookupAndTraverseRequest::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + LookupAndTraverseRequest, + ::apache::thrift::type_class::structure, + ::nebula::storage::cpp2::IndexSpec>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + LookupAndTraverseRequest, + ::apache::thrift::type_class::structure, + ::nebula::storage::cpp2::TraverseSpec>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + LookupAndTraverseRequest, + ::apache::thrift::type_class::structure, + ::nebula::storage::cpp2::RequestCommon>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + LookupAndTraverseRequest, + ::apache::thrift::type_class::structure, + ::nebula::storage::cpp2::IndexSpec>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + LookupAndTraverseRequest, + ::apache::thrift::type_class::structure, + ::nebula::storage::cpp2::TraverseSpec>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + LookupAndTraverseRequest, + ::apache::thrift::type_class::structure, + ::nebula::storage::cpp2::RequestCommon>, + "inconsistent use of nimble option"); + +}}} // nebula::storage::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::storage::cpp2::ScanVertexRequest>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::storage::cpp2::ScanVertexRequest>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace storage { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +ScanVertexRequest::ScanVertexRequest() : + space_id(0), + part_id(0), + limit(0), + start_time(0), + end_time(0), + only_latest_version(false), + enable_read_from_follower(true) {} +THRIFT_IGNORE_ISSET_USE_WARNING_END + + +ScanVertexRequest::~ScanVertexRequest() {} + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +ScanVertexRequest::ScanVertexRequest(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, ::nebula::cpp2::PartitionID part_id__arg, ::std::string cursor__arg, ::nebula::storage::cpp2::VertexProp return_columns__arg, int64_t limit__arg, int64_t start_time__arg, int64_t end_time__arg, ::std::string filter__arg, bool only_latest_version__arg, bool enable_read_from_follower__arg, ::nebula::storage::cpp2::RequestCommon common__arg) : + space_id(std::move(space_id__arg)), + part_id(std::move(part_id__arg)), + cursor(std::move(cursor__arg)), + return_columns(std::move(return_columns__arg)), + limit(std::move(limit__arg)), + start_time(std::move(start_time__arg)), + end_time(std::move(end_time__arg)), + filter(std::move(filter__arg)), + only_latest_version(std::move(only_latest_version__arg)), + enable_read_from_follower(std::move(enable_read_from_follower__arg)), + common(std::move(common__arg)) { + __isset.space_id = true; + __isset.part_id = true; + __isset.cursor = true; + __isset.return_columns = true; + __isset.limit = true; + __isset.start_time = true; + __isset.end_time = true; + __isset.filter = true; + __isset.only_latest_version = true; + __isset.enable_read_from_follower = true; + __isset.common = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void ScanVertexRequest::__clear() { + // clear all fields + space_id = 0; + part_id = 0; + cursor = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); + return_columns.__clear(); + limit = 0; + start_time = 0; + end_time = 0; + filter = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); + only_latest_version = false; + enable_read_from_follower = true; + common.__clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool ScanVertexRequest::operator==(const ScanVertexRequest& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return false; + } + if (!(lhs.part_id == rhs.part_id)) { + return false; + } + if (lhs.cursor_ref().has_value() != rhs.cursor_ref().has_value()) { + return false; + } + if (lhs.cursor_ref().has_value()) { + if (!apache::thrift::StringTraits::isEqual(lhs.cursor, rhs.cursor)) { + return false; + } + } + if (!(lhs.return_columns == rhs.return_columns)) { + return false; + } + if (!(lhs.limit == rhs.limit)) { + return false; + } + if (lhs.start_time_ref() != rhs.start_time_ref()) { + return false; + } + if (lhs.end_time_ref() != rhs.end_time_ref()) { + return false; + } + if (lhs.filter_ref().has_value() != rhs.filter_ref().has_value()) { + return false; + } + if (lhs.filter_ref().has_value()) { + if (!apache::thrift::StringTraits::isEqual(lhs.filter, rhs.filter)) { + return false; + } + } + if (!(lhs.only_latest_version == rhs.only_latest_version)) { + return false; + } + if (!(lhs.enable_read_from_follower == rhs.enable_read_from_follower)) { + return false; + } + if (lhs.common_ref() != rhs.common_ref()) { + return false; + } + return true; +} + +bool ScanVertexRequest::operator<(const ScanVertexRequest& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return lhs.space_id < rhs.space_id; + } + if (!(lhs.part_id == rhs.part_id)) { + return lhs.part_id < rhs.part_id; + } + if (lhs.cursor_ref().has_value() != rhs.cursor_ref().has_value()) { + return lhs.cursor_ref().has_value() < rhs.cursor_ref().has_value(); + } + if (lhs.cursor_ref().has_value()) { + if (!apache::thrift::StringTraits::isEqual(lhs.cursor, rhs.cursor)) { + return apache::thrift::StringTraits::isLess(lhs.cursor, rhs.cursor); + } + } + if (!(lhs.return_columns == rhs.return_columns)) { + return lhs.return_columns < rhs.return_columns; + } + if (!(lhs.limit == rhs.limit)) { + return lhs.limit < rhs.limit; + } + if (lhs.start_time_ref() != rhs.start_time_ref()) { + return lhs.start_time_ref() < rhs.start_time_ref(); + } + if (lhs.end_time_ref() != rhs.end_time_ref()) { + return lhs.end_time_ref() < rhs.end_time_ref(); + } + if (lhs.filter_ref().has_value() != rhs.filter_ref().has_value()) { + return lhs.filter_ref().has_value() < rhs.filter_ref().has_value(); + } + if (lhs.filter_ref().has_value()) { + if (!apache::thrift::StringTraits::isEqual(lhs.filter, rhs.filter)) { + return apache::thrift::StringTraits::isLess(lhs.filter, rhs.filter); + } + } + if (!(lhs.only_latest_version == rhs.only_latest_version)) { + return lhs.only_latest_version < rhs.only_latest_version; + } + if (!(lhs.enable_read_from_follower == rhs.enable_read_from_follower)) { + return lhs.enable_read_from_follower < rhs.enable_read_from_follower; + } + if (lhs.common_ref() != rhs.common_ref()) { + return lhs.common_ref() < rhs.common_ref(); + } + return false; +} + +const ::nebula::storage::cpp2::VertexProp& ScanVertexRequest::get_return_columns() const& { + return return_columns; +} + + ::nebula::storage::cpp2::VertexProp ScanVertexRequest::get_return_columns() && { + return std::move(return_columns); +} + +const ::nebula::storage::cpp2::RequestCommon* ScanVertexRequest::get_common() const& { + return common_ref().has_value() ? std::addressof(common) : nullptr; +} + + ::nebula::storage::cpp2::RequestCommon* ScanVertexRequest::get_common() & { + return common_ref().has_value() ? std::addressof(common) : nullptr; +} + + +void swap(ScanVertexRequest& a, ScanVertexRequest& b) { + using ::std::swap; + swap(a.space_id_ref().value(), b.space_id_ref().value()); + swap(a.part_id_ref().value(), b.part_id_ref().value()); + swap(a.cursor_ref().value_unchecked(), b.cursor_ref().value_unchecked()); + swap(a.return_columns_ref().value(), b.return_columns_ref().value()); + swap(a.limit_ref().value(), b.limit_ref().value()); + swap(a.start_time_ref().value_unchecked(), b.start_time_ref().value_unchecked()); + swap(a.end_time_ref().value_unchecked(), b.end_time_ref().value_unchecked()); + swap(a.filter_ref().value_unchecked(), b.filter_ref().value_unchecked()); + swap(a.only_latest_version_ref().value(), b.only_latest_version_ref().value()); + swap(a.enable_read_from_follower_ref().value(), b.enable_read_from_follower_ref().value()); + swap(a.common_ref().value_unchecked(), b.common_ref().value_unchecked()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void ScanVertexRequest::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t ScanVertexRequest::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t ScanVertexRequest::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t ScanVertexRequest::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void ScanVertexRequest::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t ScanVertexRequest::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t ScanVertexRequest::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t ScanVertexRequest::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + ScanVertexRequest, + ::apache::thrift::type_class::structure, + ::nebula::storage::cpp2::VertexProp>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + ScanVertexRequest, + ::apache::thrift::type_class::structure, + ::nebula::storage::cpp2::RequestCommon>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + ScanVertexRequest, + ::apache::thrift::type_class::structure, + ::nebula::storage::cpp2::VertexProp>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + ScanVertexRequest, + ::apache::thrift::type_class::structure, + ::nebula::storage::cpp2::RequestCommon>, + "inconsistent use of nimble option"); + +}}} // nebula::storage::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::storage::cpp2::ScanVertexResponse>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::storage::cpp2::ScanVertexResponse>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace storage { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +ScanVertexResponse::ScanVertexResponse(apache::thrift::FragileConstructor, ::nebula::storage::cpp2::ResponseCommon result__arg, nebula::DataSet vertex_data__arg, bool has_next__arg, ::std::string next_cursor__arg) : + result(std::move(result__arg)), + vertex_data(std::move(vertex_data__arg)), + has_next(std::move(has_next__arg)), + next_cursor(std::move(next_cursor__arg)) { + __isset.vertex_data = true; + __isset.has_next = true; + __isset.next_cursor = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void ScanVertexResponse::__clear() { + // clear all fields + result.__clear(); + vertex_data.__clear(); + has_next = 0; + next_cursor = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool ScanVertexResponse::operator==(const ScanVertexResponse& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.result == rhs.result)) { + return false; + } + if (!(lhs.vertex_data == rhs.vertex_data)) { + return false; + } + if (!(lhs.has_next == rhs.has_next)) { + return false; + } + if (lhs.next_cursor_ref().has_value() != rhs.next_cursor_ref().has_value()) { + return false; + } + if (lhs.next_cursor_ref().has_value()) { + if (!apache::thrift::StringTraits::isEqual(lhs.next_cursor, rhs.next_cursor)) { + return false; + } + } + return true; +} + +const ::nebula::storage::cpp2::ResponseCommon& ScanVertexResponse::get_result() const& { + return result; +} + + ::nebula::storage::cpp2::ResponseCommon ScanVertexResponse::get_result() && { + return std::move(result); +} + +const nebula::DataSet& ScanVertexResponse::get_vertex_data() const& { + return vertex_data; +} + +nebula::DataSet ScanVertexResponse::get_vertex_data() && { + return std::move(vertex_data); +} + + +void swap(ScanVertexResponse& a, ScanVertexResponse& b) { + using ::std::swap; + swap(a.result_ref().value(), b.result_ref().value()); + swap(a.vertex_data_ref().value(), b.vertex_data_ref().value()); + swap(a.has_next_ref().value(), b.has_next_ref().value()); + swap(a.next_cursor_ref().value_unchecked(), b.next_cursor_ref().value_unchecked()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void ScanVertexResponse::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t ScanVertexResponse::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t ScanVertexResponse::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t ScanVertexResponse::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void ScanVertexResponse::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t ScanVertexResponse::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t ScanVertexResponse::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t ScanVertexResponse::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + ScanVertexResponse, + ::apache::thrift::type_class::structure, + ::nebula::storage::cpp2::ResponseCommon>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + ScanVertexResponse, + ::apache::thrift::type_class::structure, + nebula::DataSet>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + ScanVertexResponse, + ::apache::thrift::type_class::structure, + ::nebula::storage::cpp2::ResponseCommon>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + ScanVertexResponse, + ::apache::thrift::type_class::structure, + nebula::DataSet>, + "inconsistent use of nimble option"); + +}}} // nebula::storage::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::storage::cpp2::ScanEdgeRequest>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::storage::cpp2::ScanEdgeRequest>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace storage { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +ScanEdgeRequest::ScanEdgeRequest() : + space_id(0), + part_id(0), + limit(0), + start_time(0), + end_time(0), + only_latest_version(false), + enable_read_from_follower(true) {} +THRIFT_IGNORE_ISSET_USE_WARNING_END + + +ScanEdgeRequest::~ScanEdgeRequest() {} + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +ScanEdgeRequest::ScanEdgeRequest(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, ::nebula::cpp2::PartitionID part_id__arg, ::std::string cursor__arg, ::nebula::storage::cpp2::EdgeProp return_columns__arg, int64_t limit__arg, int64_t start_time__arg, int64_t end_time__arg, ::std::string filter__arg, bool only_latest_version__arg, bool enable_read_from_follower__arg, ::nebula::storage::cpp2::RequestCommon common__arg) : + space_id(std::move(space_id__arg)), + part_id(std::move(part_id__arg)), + cursor(std::move(cursor__arg)), + return_columns(std::move(return_columns__arg)), + limit(std::move(limit__arg)), + start_time(std::move(start_time__arg)), + end_time(std::move(end_time__arg)), + filter(std::move(filter__arg)), + only_latest_version(std::move(only_latest_version__arg)), + enable_read_from_follower(std::move(enable_read_from_follower__arg)), + common(std::move(common__arg)) { + __isset.space_id = true; + __isset.part_id = true; + __isset.cursor = true; + __isset.return_columns = true; + __isset.limit = true; + __isset.start_time = true; + __isset.end_time = true; + __isset.filter = true; + __isset.only_latest_version = true; + __isset.enable_read_from_follower = true; + __isset.common = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void ScanEdgeRequest::__clear() { + // clear all fields + space_id = 0; + part_id = 0; + cursor = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); + return_columns.__clear(); + limit = 0; + start_time = 0; + end_time = 0; + filter = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); + only_latest_version = false; + enable_read_from_follower = true; + common.__clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool ScanEdgeRequest::operator==(const ScanEdgeRequest& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return false; + } + if (!(lhs.part_id == rhs.part_id)) { + return false; + } + if (lhs.cursor_ref().has_value() != rhs.cursor_ref().has_value()) { + return false; + } + if (lhs.cursor_ref().has_value()) { + if (!apache::thrift::StringTraits::isEqual(lhs.cursor, rhs.cursor)) { + return false; + } + } + if (!(lhs.return_columns == rhs.return_columns)) { + return false; + } + if (!(lhs.limit == rhs.limit)) { + return false; + } + if (lhs.start_time_ref() != rhs.start_time_ref()) { + return false; + } + if (lhs.end_time_ref() != rhs.end_time_ref()) { + return false; + } + if (lhs.filter_ref().has_value() != rhs.filter_ref().has_value()) { + return false; + } + if (lhs.filter_ref().has_value()) { + if (!apache::thrift::StringTraits::isEqual(lhs.filter, rhs.filter)) { + return false; + } + } + if (!(lhs.only_latest_version == rhs.only_latest_version)) { + return false; + } + if (!(lhs.enable_read_from_follower == rhs.enable_read_from_follower)) { + return false; + } + if (lhs.common_ref() != rhs.common_ref()) { + return false; + } + return true; +} + +bool ScanEdgeRequest::operator<(const ScanEdgeRequest& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return lhs.space_id < rhs.space_id; + } + if (!(lhs.part_id == rhs.part_id)) { + return lhs.part_id < rhs.part_id; + } + if (lhs.cursor_ref().has_value() != rhs.cursor_ref().has_value()) { + return lhs.cursor_ref().has_value() < rhs.cursor_ref().has_value(); + } + if (lhs.cursor_ref().has_value()) { + if (!apache::thrift::StringTraits::isEqual(lhs.cursor, rhs.cursor)) { + return apache::thrift::StringTraits::isLess(lhs.cursor, rhs.cursor); + } + } + if (!(lhs.return_columns == rhs.return_columns)) { + return lhs.return_columns < rhs.return_columns; + } + if (!(lhs.limit == rhs.limit)) { + return lhs.limit < rhs.limit; + } + if (lhs.start_time_ref() != rhs.start_time_ref()) { + return lhs.start_time_ref() < rhs.start_time_ref(); + } + if (lhs.end_time_ref() != rhs.end_time_ref()) { + return lhs.end_time_ref() < rhs.end_time_ref(); + } + if (lhs.filter_ref().has_value() != rhs.filter_ref().has_value()) { + return lhs.filter_ref().has_value() < rhs.filter_ref().has_value(); + } + if (lhs.filter_ref().has_value()) { + if (!apache::thrift::StringTraits::isEqual(lhs.filter, rhs.filter)) { + return apache::thrift::StringTraits::isLess(lhs.filter, rhs.filter); + } + } + if (!(lhs.only_latest_version == rhs.only_latest_version)) { + return lhs.only_latest_version < rhs.only_latest_version; + } + if (!(lhs.enable_read_from_follower == rhs.enable_read_from_follower)) { + return lhs.enable_read_from_follower < rhs.enable_read_from_follower; + } + if (lhs.common_ref() != rhs.common_ref()) { + return lhs.common_ref() < rhs.common_ref(); + } + return false; +} + +const ::nebula::storage::cpp2::EdgeProp& ScanEdgeRequest::get_return_columns() const& { + return return_columns; +} + + ::nebula::storage::cpp2::EdgeProp ScanEdgeRequest::get_return_columns() && { + return std::move(return_columns); +} + +const ::nebula::storage::cpp2::RequestCommon* ScanEdgeRequest::get_common() const& { + return common_ref().has_value() ? std::addressof(common) : nullptr; +} + + ::nebula::storage::cpp2::RequestCommon* ScanEdgeRequest::get_common() & { + return common_ref().has_value() ? std::addressof(common) : nullptr; +} + + +void swap(ScanEdgeRequest& a, ScanEdgeRequest& b) { + using ::std::swap; + swap(a.space_id_ref().value(), b.space_id_ref().value()); + swap(a.part_id_ref().value(), b.part_id_ref().value()); + swap(a.cursor_ref().value_unchecked(), b.cursor_ref().value_unchecked()); + swap(a.return_columns_ref().value(), b.return_columns_ref().value()); + swap(a.limit_ref().value(), b.limit_ref().value()); + swap(a.start_time_ref().value_unchecked(), b.start_time_ref().value_unchecked()); + swap(a.end_time_ref().value_unchecked(), b.end_time_ref().value_unchecked()); + swap(a.filter_ref().value_unchecked(), b.filter_ref().value_unchecked()); + swap(a.only_latest_version_ref().value(), b.only_latest_version_ref().value()); + swap(a.enable_read_from_follower_ref().value(), b.enable_read_from_follower_ref().value()); + swap(a.common_ref().value_unchecked(), b.common_ref().value_unchecked()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void ScanEdgeRequest::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t ScanEdgeRequest::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t ScanEdgeRequest::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t ScanEdgeRequest::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void ScanEdgeRequest::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t ScanEdgeRequest::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t ScanEdgeRequest::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t ScanEdgeRequest::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + ScanEdgeRequest, + ::apache::thrift::type_class::structure, + ::nebula::storage::cpp2::EdgeProp>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + ScanEdgeRequest, + ::apache::thrift::type_class::structure, + ::nebula::storage::cpp2::RequestCommon>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + ScanEdgeRequest, + ::apache::thrift::type_class::structure, + ::nebula::storage::cpp2::EdgeProp>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + ScanEdgeRequest, + ::apache::thrift::type_class::structure, + ::nebula::storage::cpp2::RequestCommon>, + "inconsistent use of nimble option"); + +}}} // nebula::storage::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::storage::cpp2::ScanEdgeResponse>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::storage::cpp2::ScanEdgeResponse>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace storage { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +ScanEdgeResponse::ScanEdgeResponse(apache::thrift::FragileConstructor, ::nebula::storage::cpp2::ResponseCommon result__arg, nebula::DataSet edge_data__arg, bool has_next__arg, ::std::string next_cursor__arg) : + result(std::move(result__arg)), + edge_data(std::move(edge_data__arg)), + has_next(std::move(has_next__arg)), + next_cursor(std::move(next_cursor__arg)) { + __isset.edge_data = true; + __isset.has_next = true; + __isset.next_cursor = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void ScanEdgeResponse::__clear() { + // clear all fields + result.__clear(); + edge_data.__clear(); + has_next = 0; + next_cursor = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool ScanEdgeResponse::operator==(const ScanEdgeResponse& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.result == rhs.result)) { + return false; + } + if (!(lhs.edge_data == rhs.edge_data)) { + return false; + } + if (!(lhs.has_next == rhs.has_next)) { + return false; + } + if (lhs.next_cursor_ref().has_value() != rhs.next_cursor_ref().has_value()) { + return false; + } + if (lhs.next_cursor_ref().has_value()) { + if (!apache::thrift::StringTraits::isEqual(lhs.next_cursor, rhs.next_cursor)) { + return false; + } + } + return true; +} + +const ::nebula::storage::cpp2::ResponseCommon& ScanEdgeResponse::get_result() const& { + return result; +} + + ::nebula::storage::cpp2::ResponseCommon ScanEdgeResponse::get_result() && { + return std::move(result); +} + +const nebula::DataSet& ScanEdgeResponse::get_edge_data() const& { + return edge_data; +} + +nebula::DataSet ScanEdgeResponse::get_edge_data() && { + return std::move(edge_data); +} + + +void swap(ScanEdgeResponse& a, ScanEdgeResponse& b) { + using ::std::swap; + swap(a.result_ref().value(), b.result_ref().value()); + swap(a.edge_data_ref().value(), b.edge_data_ref().value()); + swap(a.has_next_ref().value(), b.has_next_ref().value()); + swap(a.next_cursor_ref().value_unchecked(), b.next_cursor_ref().value_unchecked()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void ScanEdgeResponse::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t ScanEdgeResponse::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t ScanEdgeResponse::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t ScanEdgeResponse::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void ScanEdgeResponse::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t ScanEdgeResponse::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t ScanEdgeResponse::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t ScanEdgeResponse::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + ScanEdgeResponse, + ::apache::thrift::type_class::structure, + ::nebula::storage::cpp2::ResponseCommon>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + ScanEdgeResponse, + ::apache::thrift::type_class::structure, + nebula::DataSet>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + ScanEdgeResponse, + ::apache::thrift::type_class::structure, + ::nebula::storage::cpp2::ResponseCommon>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + ScanEdgeResponse, + ::apache::thrift::type_class::structure, + nebula::DataSet>, + "inconsistent use of nimble option"); + +}}} // nebula::storage::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::storage::cpp2::TaskPara>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::storage::cpp2::TaskPara>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace storage { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +TaskPara::TaskPara(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, ::std::vector< ::nebula::cpp2::PartitionID> parts__arg, ::std::vector<::std::string> task_specfic_paras__arg) : + space_id(std::move(space_id__arg)), + parts(std::move(parts__arg)), + task_specfic_paras(std::move(task_specfic_paras__arg)) { + __isset.space_id = true; + __isset.parts = true; + __isset.task_specfic_paras = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void TaskPara::__clear() { + // clear all fields + space_id = 0; + parts.clear(); + task_specfic_paras.clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool TaskPara::operator==(const TaskPara& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return false; + } + if (lhs.parts_ref() != rhs.parts_ref()) { + return false; + } + if (lhs.task_specfic_paras_ref() != rhs.task_specfic_paras_ref()) { + return false; + } + return true; +} + +bool TaskPara::operator<(const TaskPara& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return lhs.space_id < rhs.space_id; + } + if (lhs.parts_ref() != rhs.parts_ref()) { + return lhs.parts_ref() < rhs.parts_ref(); + } + if (lhs.task_specfic_paras_ref() != rhs.task_specfic_paras_ref()) { + return lhs.task_specfic_paras_ref() < rhs.task_specfic_paras_ref(); + } + return false; +} + +const ::std::vector< ::nebula::cpp2::PartitionID>* TaskPara::get_parts() const& { + return parts_ref().has_value() ? std::addressof(parts) : nullptr; +} + +::std::vector< ::nebula::cpp2::PartitionID>* TaskPara::get_parts() & { + return parts_ref().has_value() ? std::addressof(parts) : nullptr; +} + +const ::std::vector<::std::string>* TaskPara::get_task_specfic_paras() const& { + return task_specfic_paras_ref().has_value() ? std::addressof(task_specfic_paras) : nullptr; +} + +::std::vector<::std::string>* TaskPara::get_task_specfic_paras() & { + return task_specfic_paras_ref().has_value() ? std::addressof(task_specfic_paras) : nullptr; +} + + +void swap(TaskPara& a, TaskPara& b) { + using ::std::swap; + swap(a.space_id_ref().value(), b.space_id_ref().value()); + swap(a.parts_ref().value_unchecked(), b.parts_ref().value_unchecked()); + swap(a.task_specfic_paras_ref().value_unchecked(), b.task_specfic_paras_ref().value_unchecked()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void TaskPara::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t TaskPara::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t TaskPara::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t TaskPara::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void TaskPara::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t TaskPara::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t TaskPara::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t TaskPara::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::storage::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::storage::cpp2::AddAdminTaskRequest>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::storage::cpp2::AddAdminTaskRequest>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace storage { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +AddAdminTaskRequest::AddAdminTaskRequest(apache::thrift::FragileConstructor, ::nebula::meta::cpp2::AdminCmd cmd__arg, int32_t job_id__arg, int32_t task_id__arg, ::nebula::storage::cpp2::TaskPara para__arg, int32_t concurrency__arg) : + cmd(std::move(cmd__arg)), + job_id(std::move(job_id__arg)), + task_id(std::move(task_id__arg)), + para(std::move(para__arg)), + concurrency(std::move(concurrency__arg)) { + __isset.cmd = true; + __isset.job_id = true; + __isset.task_id = true; + __isset.para = true; + __isset.concurrency = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void AddAdminTaskRequest::__clear() { + // clear all fields + cmd = ::nebula::meta::cpp2::AdminCmd::COMPACT; + job_id = 0; + task_id = 0; + para.__clear(); + concurrency = 0; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool AddAdminTaskRequest::operator==(const AddAdminTaskRequest& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.cmd == rhs.cmd)) { + return false; + } + if (!(lhs.job_id == rhs.job_id)) { + return false; + } + if (!(lhs.task_id == rhs.task_id)) { + return false; + } + if (!(lhs.para == rhs.para)) { + return false; + } + if (lhs.concurrency_ref() != rhs.concurrency_ref()) { + return false; + } + return true; +} + +bool AddAdminTaskRequest::operator<(const AddAdminTaskRequest& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.cmd == rhs.cmd)) { + return lhs.cmd < rhs.cmd; + } + if (!(lhs.job_id == rhs.job_id)) { + return lhs.job_id < rhs.job_id; + } + if (!(lhs.task_id == rhs.task_id)) { + return lhs.task_id < rhs.task_id; + } + if (!(lhs.para == rhs.para)) { + return lhs.para < rhs.para; + } + if (lhs.concurrency_ref() != rhs.concurrency_ref()) { + return lhs.concurrency_ref() < rhs.concurrency_ref(); + } + return false; +} + +const ::nebula::storage::cpp2::TaskPara& AddAdminTaskRequest::get_para() const& { + return para; +} + + ::nebula::storage::cpp2::TaskPara AddAdminTaskRequest::get_para() && { + return std::move(para); +} + + +void swap(AddAdminTaskRequest& a, AddAdminTaskRequest& b) { + using ::std::swap; + swap(a.cmd_ref().value(), b.cmd_ref().value()); + swap(a.job_id_ref().value(), b.job_id_ref().value()); + swap(a.task_id_ref().value(), b.task_id_ref().value()); + swap(a.para_ref().value(), b.para_ref().value()); + swap(a.concurrency_ref().value_unchecked(), b.concurrency_ref().value_unchecked()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void AddAdminTaskRequest::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t AddAdminTaskRequest::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t AddAdminTaskRequest::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t AddAdminTaskRequest::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void AddAdminTaskRequest::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t AddAdminTaskRequest::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t AddAdminTaskRequest::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t AddAdminTaskRequest::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + AddAdminTaskRequest, + ::apache::thrift::type_class::structure, + ::nebula::storage::cpp2::TaskPara>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + AddAdminTaskRequest, + ::apache::thrift::type_class::structure, + ::nebula::storage::cpp2::TaskPara>, + "inconsistent use of nimble option"); + +}}} // nebula::storage::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::storage::cpp2::StopAdminTaskRequest>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::storage::cpp2::StopAdminTaskRequest>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace storage { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +StopAdminTaskRequest::StopAdminTaskRequest(apache::thrift::FragileConstructor, int32_t job_id__arg, int32_t task_id__arg) : + job_id(std::move(job_id__arg)), + task_id(std::move(task_id__arg)) { + __isset.job_id = true; + __isset.task_id = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void StopAdminTaskRequest::__clear() { + // clear all fields + job_id = 0; + task_id = 0; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool StopAdminTaskRequest::operator==(const StopAdminTaskRequest& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.job_id == rhs.job_id)) { + return false; + } + if (!(lhs.task_id == rhs.task_id)) { + return false; + } + return true; +} + +bool StopAdminTaskRequest::operator<(const StopAdminTaskRequest& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.job_id == rhs.job_id)) { + return lhs.job_id < rhs.job_id; + } + if (!(lhs.task_id == rhs.task_id)) { + return lhs.task_id < rhs.task_id; + } + return false; +} + + +void swap(StopAdminTaskRequest& a, StopAdminTaskRequest& b) { + using ::std::swap; + swap(a.job_id_ref().value(), b.job_id_ref().value()); + swap(a.task_id_ref().value(), b.task_id_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void StopAdminTaskRequest::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t StopAdminTaskRequest::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t StopAdminTaskRequest::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t StopAdminTaskRequest::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void StopAdminTaskRequest::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t StopAdminTaskRequest::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t StopAdminTaskRequest::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t StopAdminTaskRequest::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::storage::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::storage::cpp2::AdminExecResp>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::storage::cpp2::AdminExecResp>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace storage { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +AdminExecResp::AdminExecResp(apache::thrift::FragileConstructor, ::nebula::storage::cpp2::ResponseCommon result__arg, ::nebula::meta::cpp2::StatsItem stats__arg) : + result(std::move(result__arg)), + stats(std::move(stats__arg)) { + __isset.stats = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void AdminExecResp::__clear() { + // clear all fields + result.__clear(); + stats.__clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool AdminExecResp::operator==(const AdminExecResp& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.result == rhs.result)) { + return false; + } + if (lhs.stats_ref() != rhs.stats_ref()) { + return false; + } + return true; +} + +const ::nebula::storage::cpp2::ResponseCommon& AdminExecResp::get_result() const& { + return result; +} + + ::nebula::storage::cpp2::ResponseCommon AdminExecResp::get_result() && { + return std::move(result); +} + +const ::nebula::meta::cpp2::StatsItem* AdminExecResp::get_stats() const& { + return stats_ref().has_value() ? std::addressof(stats) : nullptr; +} + + ::nebula::meta::cpp2::StatsItem* AdminExecResp::get_stats() & { + return stats_ref().has_value() ? std::addressof(stats) : nullptr; +} + + +void swap(AdminExecResp& a, AdminExecResp& b) { + using ::std::swap; + swap(a.result_ref().value(), b.result_ref().value()); + swap(a.stats_ref().value_unchecked(), b.stats_ref().value_unchecked()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void AdminExecResp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t AdminExecResp::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t AdminExecResp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t AdminExecResp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void AdminExecResp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t AdminExecResp::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t AdminExecResp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t AdminExecResp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + AdminExecResp, + ::apache::thrift::type_class::structure, + ::nebula::storage::cpp2::ResponseCommon>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + AdminExecResp, + ::apache::thrift::type_class::structure, + ::nebula::meta::cpp2::StatsItem>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + AdminExecResp, + ::apache::thrift::type_class::structure, + ::nebula::storage::cpp2::ResponseCommon>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + AdminExecResp, + ::apache::thrift::type_class::structure, + ::nebula::meta::cpp2::StatsItem>, + "inconsistent use of nimble option"); + +}}} // nebula::storage::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::storage::cpp2::TransLeaderReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::storage::cpp2::TransLeaderReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace storage { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +TransLeaderReq::TransLeaderReq(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, ::nebula::cpp2::PartitionID part_id__arg, nebula::HostAddr new_leader__arg) : + space_id(std::move(space_id__arg)), + part_id(std::move(part_id__arg)), + new_leader(std::move(new_leader__arg)) { + __isset.space_id = true; + __isset.part_id = true; + __isset.new_leader = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void TransLeaderReq::__clear() { + // clear all fields + space_id = 0; + part_id = 0; + new_leader.__clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool TransLeaderReq::operator==(const TransLeaderReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return false; + } + if (!(lhs.part_id == rhs.part_id)) { + return false; + } + if (!(lhs.new_leader == rhs.new_leader)) { + return false; + } + return true; +} + +bool TransLeaderReq::operator<(const TransLeaderReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return lhs.space_id < rhs.space_id; + } + if (!(lhs.part_id == rhs.part_id)) { + return lhs.part_id < rhs.part_id; + } + if (!(lhs.new_leader == rhs.new_leader)) { + return lhs.new_leader < rhs.new_leader; + } + return false; +} + +const nebula::HostAddr& TransLeaderReq::get_new_leader() const& { + return new_leader; +} + +nebula::HostAddr TransLeaderReq::get_new_leader() && { + return std::move(new_leader); +} + + +void swap(TransLeaderReq& a, TransLeaderReq& b) { + using ::std::swap; + swap(a.space_id_ref().value(), b.space_id_ref().value()); + swap(a.part_id_ref().value(), b.part_id_ref().value()); + swap(a.new_leader_ref().value(), b.new_leader_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void TransLeaderReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t TransLeaderReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t TransLeaderReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t TransLeaderReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void TransLeaderReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t TransLeaderReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t TransLeaderReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t TransLeaderReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + TransLeaderReq, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + TransLeaderReq, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of nimble option"); + +}}} // nebula::storage::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::storage::cpp2::AddPartReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::storage::cpp2::AddPartReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace storage { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +AddPartReq::AddPartReq(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, ::nebula::cpp2::PartitionID part_id__arg, bool as_learner__arg, ::std::vector peers__arg) : + space_id(std::move(space_id__arg)), + part_id(std::move(part_id__arg)), + as_learner(std::move(as_learner__arg)), + peers(std::move(peers__arg)) { + __isset.space_id = true; + __isset.part_id = true; + __isset.as_learner = true; + __isset.peers = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void AddPartReq::__clear() { + // clear all fields + space_id = 0; + part_id = 0; + as_learner = 0; + peers.clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool AddPartReq::operator==(const AddPartReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return false; + } + if (!(lhs.part_id == rhs.part_id)) { + return false; + } + if (!(lhs.as_learner == rhs.as_learner)) { + return false; + } + if (!(lhs.peers == rhs.peers)) { + return false; + } + return true; +} + +bool AddPartReq::operator<(const AddPartReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return lhs.space_id < rhs.space_id; + } + if (!(lhs.part_id == rhs.part_id)) { + return lhs.part_id < rhs.part_id; + } + if (!(lhs.as_learner == rhs.as_learner)) { + return lhs.as_learner < rhs.as_learner; + } + if (!(lhs.peers == rhs.peers)) { + return lhs.peers < rhs.peers; + } + return false; +} + +const ::std::vector& AddPartReq::get_peers() const& { + return peers; +} + +::std::vector AddPartReq::get_peers() && { + return std::move(peers); +} + + +void swap(AddPartReq& a, AddPartReq& b) { + using ::std::swap; + swap(a.space_id_ref().value(), b.space_id_ref().value()); + swap(a.part_id_ref().value(), b.part_id_ref().value()); + swap(a.as_learner_ref().value(), b.as_learner_ref().value()); + swap(a.peers_ref().value(), b.peers_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void AddPartReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t AddPartReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t AddPartReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t AddPartReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void AddPartReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t AddPartReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t AddPartReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t AddPartReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + AddPartReq, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + AddPartReq, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector>, + "inconsistent use of nimble option"); + +}}} // nebula::storage::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::storage::cpp2::AddLearnerReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::storage::cpp2::AddLearnerReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace storage { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +AddLearnerReq::AddLearnerReq(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, ::nebula::cpp2::PartitionID part_id__arg, nebula::HostAddr learner__arg) : + space_id(std::move(space_id__arg)), + part_id(std::move(part_id__arg)), + learner(std::move(learner__arg)) { + __isset.space_id = true; + __isset.part_id = true; + __isset.learner = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void AddLearnerReq::__clear() { + // clear all fields + space_id = 0; + part_id = 0; + learner.__clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool AddLearnerReq::operator==(const AddLearnerReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return false; + } + if (!(lhs.part_id == rhs.part_id)) { + return false; + } + if (!(lhs.learner == rhs.learner)) { + return false; + } + return true; +} + +bool AddLearnerReq::operator<(const AddLearnerReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return lhs.space_id < rhs.space_id; + } + if (!(lhs.part_id == rhs.part_id)) { + return lhs.part_id < rhs.part_id; + } + if (!(lhs.learner == rhs.learner)) { + return lhs.learner < rhs.learner; + } + return false; +} + +const nebula::HostAddr& AddLearnerReq::get_learner() const& { + return learner; +} + +nebula::HostAddr AddLearnerReq::get_learner() && { + return std::move(learner); +} + + +void swap(AddLearnerReq& a, AddLearnerReq& b) { + using ::std::swap; + swap(a.space_id_ref().value(), b.space_id_ref().value()); + swap(a.part_id_ref().value(), b.part_id_ref().value()); + swap(a.learner_ref().value(), b.learner_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void AddLearnerReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t AddLearnerReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t AddLearnerReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t AddLearnerReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void AddLearnerReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t AddLearnerReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t AddLearnerReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t AddLearnerReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + AddLearnerReq, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + AddLearnerReq, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of nimble option"); + +}}} // nebula::storage::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::storage::cpp2::RemovePartReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::storage::cpp2::RemovePartReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace storage { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +RemovePartReq::RemovePartReq(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, ::nebula::cpp2::PartitionID part_id__arg) : + space_id(std::move(space_id__arg)), + part_id(std::move(part_id__arg)) { + __isset.space_id = true; + __isset.part_id = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void RemovePartReq::__clear() { + // clear all fields + space_id = 0; + part_id = 0; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool RemovePartReq::operator==(const RemovePartReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return false; + } + if (!(lhs.part_id == rhs.part_id)) { + return false; + } + return true; +} + +bool RemovePartReq::operator<(const RemovePartReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return lhs.space_id < rhs.space_id; + } + if (!(lhs.part_id == rhs.part_id)) { + return lhs.part_id < rhs.part_id; + } + return false; +} + + +void swap(RemovePartReq& a, RemovePartReq& b) { + using ::std::swap; + swap(a.space_id_ref().value(), b.space_id_ref().value()); + swap(a.part_id_ref().value(), b.part_id_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void RemovePartReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t RemovePartReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t RemovePartReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t RemovePartReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void RemovePartReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t RemovePartReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t RemovePartReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t RemovePartReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::storage::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::storage::cpp2::MemberChangeReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::storage::cpp2::MemberChangeReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace storage { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +MemberChangeReq::MemberChangeReq(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, ::nebula::cpp2::PartitionID part_id__arg, nebula::HostAddr peer__arg, bool add__arg) : + space_id(std::move(space_id__arg)), + part_id(std::move(part_id__arg)), + peer(std::move(peer__arg)), + add(std::move(add__arg)) { + __isset.space_id = true; + __isset.part_id = true; + __isset.peer = true; + __isset.add = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void MemberChangeReq::__clear() { + // clear all fields + space_id = 0; + part_id = 0; + peer.__clear(); + add = 0; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool MemberChangeReq::operator==(const MemberChangeReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return false; + } + if (!(lhs.part_id == rhs.part_id)) { + return false; + } + if (!(lhs.peer == rhs.peer)) { + return false; + } + if (!(lhs.add == rhs.add)) { + return false; + } + return true; +} + +bool MemberChangeReq::operator<(const MemberChangeReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return lhs.space_id < rhs.space_id; + } + if (!(lhs.part_id == rhs.part_id)) { + return lhs.part_id < rhs.part_id; + } + if (!(lhs.peer == rhs.peer)) { + return lhs.peer < rhs.peer; + } + if (!(lhs.add == rhs.add)) { + return lhs.add < rhs.add; + } + return false; +} + +const nebula::HostAddr& MemberChangeReq::get_peer() const& { + return peer; +} + +nebula::HostAddr MemberChangeReq::get_peer() && { + return std::move(peer); +} + + +void swap(MemberChangeReq& a, MemberChangeReq& b) { + using ::std::swap; + swap(a.space_id_ref().value(), b.space_id_ref().value()); + swap(a.part_id_ref().value(), b.part_id_ref().value()); + swap(a.peer_ref().value(), b.peer_ref().value()); + swap(a.add_ref().value(), b.add_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void MemberChangeReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t MemberChangeReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t MemberChangeReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t MemberChangeReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void MemberChangeReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t MemberChangeReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t MemberChangeReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t MemberChangeReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + MemberChangeReq, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + MemberChangeReq, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of nimble option"); + +}}} // nebula::storage::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::storage::cpp2::CatchUpDataReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::storage::cpp2::CatchUpDataReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace storage { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +CatchUpDataReq::CatchUpDataReq(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, ::nebula::cpp2::PartitionID part_id__arg, nebula::HostAddr target__arg) : + space_id(std::move(space_id__arg)), + part_id(std::move(part_id__arg)), + target(std::move(target__arg)) { + __isset.space_id = true; + __isset.part_id = true; + __isset.target = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void CatchUpDataReq::__clear() { + // clear all fields + space_id = 0; + part_id = 0; + target.__clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool CatchUpDataReq::operator==(const CatchUpDataReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return false; + } + if (!(lhs.part_id == rhs.part_id)) { + return false; + } + if (!(lhs.target == rhs.target)) { + return false; + } + return true; +} + +bool CatchUpDataReq::operator<(const CatchUpDataReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return lhs.space_id < rhs.space_id; + } + if (!(lhs.part_id == rhs.part_id)) { + return lhs.part_id < rhs.part_id; + } + if (!(lhs.target == rhs.target)) { + return lhs.target < rhs.target; + } + return false; +} + +const nebula::HostAddr& CatchUpDataReq::get_target() const& { + return target; +} + +nebula::HostAddr CatchUpDataReq::get_target() && { + return std::move(target); +} + + +void swap(CatchUpDataReq& a, CatchUpDataReq& b) { + using ::std::swap; + swap(a.space_id_ref().value(), b.space_id_ref().value()); + swap(a.part_id_ref().value(), b.part_id_ref().value()); + swap(a.target_ref().value(), b.target_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void CatchUpDataReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t CatchUpDataReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t CatchUpDataReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t CatchUpDataReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void CatchUpDataReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t CatchUpDataReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t CatchUpDataReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t CatchUpDataReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + CatchUpDataReq, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + CatchUpDataReq, + ::apache::thrift::type_class::structure, + nebula::HostAddr>, + "inconsistent use of nimble option"); + +}}} // nebula::storage::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::storage::cpp2::GetLeaderReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::storage::cpp2::GetLeaderReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace storage { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +GetLeaderReq::GetLeaderReq(apache::thrift::FragileConstructor) {} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void GetLeaderReq::__clear() { + // clear all fields +} + +bool GetLeaderReq::operator==(const GetLeaderReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + return true; +} + +bool GetLeaderReq::operator<(const GetLeaderReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + return false; +} + + +void swap(GetLeaderReq& a, GetLeaderReq& b) { + using ::std::swap; + (void)a; + (void)b; +} + +template void GetLeaderReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t GetLeaderReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t GetLeaderReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t GetLeaderReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void GetLeaderReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t GetLeaderReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t GetLeaderReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t GetLeaderReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::storage::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::storage::cpp2::CreateCPRequest>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::storage::cpp2::CreateCPRequest>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace storage { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +CreateCPRequest::CreateCPRequest(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, ::std::string name__arg) : + space_id(std::move(space_id__arg)), + name(std::move(name__arg)) { + __isset.space_id = true; + __isset.name = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void CreateCPRequest::__clear() { + // clear all fields + space_id = 0; + name = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool CreateCPRequest::operator==(const CreateCPRequest& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return false; + } + if (!apache::thrift::StringTraits::isEqual(lhs.name, rhs.name)) { + return false; + } + return true; +} + +bool CreateCPRequest::operator<(const CreateCPRequest& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return lhs.space_id < rhs.space_id; + } + if (!apache::thrift::StringTraits::isEqual(lhs.name, rhs.name)) { + return apache::thrift::StringTraits::isLess(lhs.name, rhs.name); + } + return false; +} + + +void swap(CreateCPRequest& a, CreateCPRequest& b) { + using ::std::swap; + swap(a.space_id_ref().value(), b.space_id_ref().value()); + swap(a.name_ref().value(), b.name_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void CreateCPRequest::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t CreateCPRequest::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t CreateCPRequest::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t CreateCPRequest::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void CreateCPRequest::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t CreateCPRequest::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t CreateCPRequest::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t CreateCPRequest::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::storage::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::storage::cpp2::DropCPRequest>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::storage::cpp2::DropCPRequest>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace storage { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +DropCPRequest::DropCPRequest(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, ::std::string name__arg) : + space_id(std::move(space_id__arg)), + name(std::move(name__arg)) { + __isset.space_id = true; + __isset.name = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void DropCPRequest::__clear() { + // clear all fields + space_id = 0; + name = apache::thrift::StringTraits< std::string>::fromStringLiteral(""); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool DropCPRequest::operator==(const DropCPRequest& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return false; + } + if (!apache::thrift::StringTraits::isEqual(lhs.name, rhs.name)) { + return false; + } + return true; +} + +bool DropCPRequest::operator<(const DropCPRequest& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return lhs.space_id < rhs.space_id; + } + if (!apache::thrift::StringTraits::isEqual(lhs.name, rhs.name)) { + return apache::thrift::StringTraits::isLess(lhs.name, rhs.name); + } + return false; +} + + +void swap(DropCPRequest& a, DropCPRequest& b) { + using ::std::swap; + swap(a.space_id_ref().value(), b.space_id_ref().value()); + swap(a.name_ref().value(), b.name_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void DropCPRequest::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t DropCPRequest::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t DropCPRequest::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t DropCPRequest::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void DropCPRequest::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t DropCPRequest::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t DropCPRequest::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t DropCPRequest::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::storage::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::storage::cpp2::BlockingSignRequest>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::storage::cpp2::BlockingSignRequest>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace storage { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +BlockingSignRequest::BlockingSignRequest(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, ::nebula::storage::cpp2::EngineSignType sign__arg) : + space_id(std::move(space_id__arg)), + sign(std::move(sign__arg)) { + __isset.space_id = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void BlockingSignRequest::__clear() { + // clear all fields + space_id = 0; + sign = static_cast< ::nebula::storage::cpp2::EngineSignType>(0); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool BlockingSignRequest::operator==(const BlockingSignRequest& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return false; + } + if (!(lhs.sign == rhs.sign)) { + return false; + } + return true; +} + +bool BlockingSignRequest::operator<(const BlockingSignRequest& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return lhs.space_id < rhs.space_id; + } + if (!(lhs.sign == rhs.sign)) { + return lhs.sign < rhs.sign; + } + return false; +} + + +void swap(BlockingSignRequest& a, BlockingSignRequest& b) { + using ::std::swap; + swap(a.space_id_ref().value(), b.space_id_ref().value()); + swap(a.sign_ref().value(), b.sign_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void BlockingSignRequest::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t BlockingSignRequest::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t BlockingSignRequest::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t BlockingSignRequest::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void BlockingSignRequest::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t BlockingSignRequest::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t BlockingSignRequest::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t BlockingSignRequest::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::storage::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::storage::cpp2::GetLeaderPartsResp>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::storage::cpp2::GetLeaderPartsResp>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace storage { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +GetLeaderPartsResp::GetLeaderPartsResp(apache::thrift::FragileConstructor, ::nebula::storage::cpp2::ResponseCommon result__arg, std::unordered_map< ::nebula::cpp2::GraphSpaceID, ::std::vector< ::nebula::cpp2::PartitionID>> leader_parts__arg) : + result(std::move(result__arg)), + leader_parts(std::move(leader_parts__arg)) { + __isset.leader_parts = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void GetLeaderPartsResp::__clear() { + // clear all fields + result.__clear(); + leader_parts.clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool GetLeaderPartsResp::operator==(const GetLeaderPartsResp& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.result == rhs.result)) { + return false; + } + if (!(lhs.leader_parts == rhs.leader_parts)) { + return false; + } + return true; +} + +const ::nebula::storage::cpp2::ResponseCommon& GetLeaderPartsResp::get_result() const& { + return result; +} + + ::nebula::storage::cpp2::ResponseCommon GetLeaderPartsResp::get_result() && { + return std::move(result); +} + +const std::unordered_map< ::nebula::cpp2::GraphSpaceID, ::std::vector< ::nebula::cpp2::PartitionID>>& GetLeaderPartsResp::get_leader_parts() const& { + return leader_parts; +} + +std::unordered_map< ::nebula::cpp2::GraphSpaceID, ::std::vector< ::nebula::cpp2::PartitionID>> GetLeaderPartsResp::get_leader_parts() && { + return std::move(leader_parts); +} + + +void swap(GetLeaderPartsResp& a, GetLeaderPartsResp& b) { + using ::std::swap; + swap(a.result_ref().value(), b.result_ref().value()); + swap(a.leader_parts_ref().value(), b.leader_parts_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void GetLeaderPartsResp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t GetLeaderPartsResp::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t GetLeaderPartsResp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t GetLeaderPartsResp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void GetLeaderPartsResp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t GetLeaderPartsResp::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t GetLeaderPartsResp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t GetLeaderPartsResp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + GetLeaderPartsResp, + ::apache::thrift::type_class::structure, + ::nebula::storage::cpp2::ResponseCommon>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + GetLeaderPartsResp, + ::apache::thrift::type_class::structure, + ::nebula::storage::cpp2::ResponseCommon>, + "inconsistent use of nimble option"); + +}}} // nebula::storage::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::storage::cpp2::CheckPeersReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::storage::cpp2::CheckPeersReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace storage { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +CheckPeersReq::CheckPeersReq(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, ::nebula::cpp2::PartitionID part_id__arg, ::std::vector peers__arg) : + space_id(std::move(space_id__arg)), + part_id(std::move(part_id__arg)), + peers(std::move(peers__arg)) { + __isset.space_id = true; + __isset.part_id = true; + __isset.peers = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void CheckPeersReq::__clear() { + // clear all fields + space_id = 0; + part_id = 0; + peers.clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool CheckPeersReq::operator==(const CheckPeersReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return false; + } + if (!(lhs.part_id == rhs.part_id)) { + return false; + } + if (!(lhs.peers == rhs.peers)) { + return false; + } + return true; +} + +bool CheckPeersReq::operator<(const CheckPeersReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return lhs.space_id < rhs.space_id; + } + if (!(lhs.part_id == rhs.part_id)) { + return lhs.part_id < rhs.part_id; + } + if (!(lhs.peers == rhs.peers)) { + return lhs.peers < rhs.peers; + } + return false; +} + +const ::std::vector& CheckPeersReq::get_peers() const& { + return peers; +} + +::std::vector CheckPeersReq::get_peers() && { + return std::move(peers); +} + + +void swap(CheckPeersReq& a, CheckPeersReq& b) { + using ::std::swap; + swap(a.space_id_ref().value(), b.space_id_ref().value()); + swap(a.part_id_ref().value(), b.part_id_ref().value()); + swap(a.peers_ref().value(), b.peers_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void CheckPeersReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t CheckPeersReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t CheckPeersReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t CheckPeersReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void CheckPeersReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t CheckPeersReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t CheckPeersReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t CheckPeersReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + CheckPeersReq, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + CheckPeersReq, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector>, + "inconsistent use of nimble option"); + +}}} // nebula::storage::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::storage::cpp2::RebuildIndexRequest>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::storage::cpp2::RebuildIndexRequest>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace storage { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +RebuildIndexRequest::RebuildIndexRequest(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, ::std::vector< ::nebula::cpp2::PartitionID> parts__arg, ::nebula::cpp2::IndexID index_id__arg) : + space_id(std::move(space_id__arg)), + parts(std::move(parts__arg)), + index_id(std::move(index_id__arg)) { + __isset.space_id = true; + __isset.parts = true; + __isset.index_id = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void RebuildIndexRequest::__clear() { + // clear all fields + space_id = 0; + parts.clear(); + index_id = 0; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool RebuildIndexRequest::operator==(const RebuildIndexRequest& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return false; + } + if (!(lhs.parts == rhs.parts)) { + return false; + } + if (!(lhs.index_id == rhs.index_id)) { + return false; + } + return true; +} + +bool RebuildIndexRequest::operator<(const RebuildIndexRequest& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return lhs.space_id < rhs.space_id; + } + if (!(lhs.parts == rhs.parts)) { + return lhs.parts < rhs.parts; + } + if (!(lhs.index_id == rhs.index_id)) { + return lhs.index_id < rhs.index_id; + } + return false; +} + +const ::std::vector< ::nebula::cpp2::PartitionID>& RebuildIndexRequest::get_parts() const& { + return parts; +} + +::std::vector< ::nebula::cpp2::PartitionID> RebuildIndexRequest::get_parts() && { + return std::move(parts); +} + + +void swap(RebuildIndexRequest& a, RebuildIndexRequest& b) { + using ::std::swap; + swap(a.space_id_ref().value(), b.space_id_ref().value()); + swap(a.parts_ref().value(), b.parts_ref().value()); + swap(a.index_id_ref().value(), b.index_id_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void RebuildIndexRequest::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t RebuildIndexRequest::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t RebuildIndexRequest::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t RebuildIndexRequest::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void RebuildIndexRequest::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t RebuildIndexRequest::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t RebuildIndexRequest::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t RebuildIndexRequest::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::storage::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::storage::cpp2::CreateCPResp>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::storage::cpp2::CreateCPResp>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace storage { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +CreateCPResp::CreateCPResp(apache::thrift::FragileConstructor, ::nebula::storage::cpp2::ResponseCommon result__arg, ::std::vector< ::nebula::cpp2::CheckpointInfo> info__arg) : + result(std::move(result__arg)), + info(std::move(info__arg)) { + __isset.info = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void CreateCPResp::__clear() { + // clear all fields + result.__clear(); + info.clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool CreateCPResp::operator==(const CreateCPResp& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.result == rhs.result)) { + return false; + } + if (!(lhs.info == rhs.info)) { + return false; + } + return true; +} + +const ::nebula::storage::cpp2::ResponseCommon& CreateCPResp::get_result() const& { + return result; +} + + ::nebula::storage::cpp2::ResponseCommon CreateCPResp::get_result() && { + return std::move(result); +} + +const ::std::vector< ::nebula::cpp2::CheckpointInfo>& CreateCPResp::get_info() const& { + return info; +} + +::std::vector< ::nebula::cpp2::CheckpointInfo> CreateCPResp::get_info() && { + return std::move(info); +} + + +void swap(CreateCPResp& a, CreateCPResp& b) { + using ::std::swap; + swap(a.result_ref().value(), b.result_ref().value()); + swap(a.info_ref().value(), b.info_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void CreateCPResp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t CreateCPResp::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t CreateCPResp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t CreateCPResp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void CreateCPResp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t CreateCPResp::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t CreateCPResp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t CreateCPResp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + CreateCPResp, + ::apache::thrift::type_class::structure, + ::nebula::storage::cpp2::ResponseCommon>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + CreateCPResp, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector< ::nebula::cpp2::CheckpointInfo>>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + CreateCPResp, + ::apache::thrift::type_class::structure, + ::nebula::storage::cpp2::ResponseCommon>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + CreateCPResp, + ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, + ::std::vector< ::nebula::cpp2::CheckpointInfo>>, + "inconsistent use of nimble option"); + +}}} // nebula::storage::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::storage::cpp2::ListClusterInfoResp>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::storage::cpp2::ListClusterInfoResp>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace storage { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +ListClusterInfoResp::ListClusterInfoResp(apache::thrift::FragileConstructor, ::nebula::storage::cpp2::ResponseCommon result__arg, ::nebula::cpp2::DirInfo dir__arg) : + result(std::move(result__arg)), + dir(std::move(dir__arg)) { + __isset.dir = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void ListClusterInfoResp::__clear() { + // clear all fields + result.__clear(); + dir.__clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool ListClusterInfoResp::operator==(const ListClusterInfoResp& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.result == rhs.result)) { + return false; + } + if (!(lhs.dir == rhs.dir)) { + return false; + } + return true; +} + +bool ListClusterInfoResp::operator<(const ListClusterInfoResp& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.result == rhs.result)) { + return lhs.result < rhs.result; + } + if (!(lhs.dir == rhs.dir)) { + return lhs.dir < rhs.dir; + } + return false; +} + +const ::nebula::storage::cpp2::ResponseCommon& ListClusterInfoResp::get_result() const& { + return result; +} + + ::nebula::storage::cpp2::ResponseCommon ListClusterInfoResp::get_result() && { + return std::move(result); +} + +const ::nebula::cpp2::DirInfo& ListClusterInfoResp::get_dir() const& { + return dir; +} + + ::nebula::cpp2::DirInfo ListClusterInfoResp::get_dir() && { + return std::move(dir); +} + + +void swap(ListClusterInfoResp& a, ListClusterInfoResp& b) { + using ::std::swap; + swap(a.result_ref().value(), b.result_ref().value()); + swap(a.dir_ref().value(), b.dir_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void ListClusterInfoResp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t ListClusterInfoResp::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t ListClusterInfoResp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t ListClusterInfoResp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void ListClusterInfoResp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t ListClusterInfoResp::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t ListClusterInfoResp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t ListClusterInfoResp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + ListClusterInfoResp, + ::apache::thrift::type_class::structure, + ::nebula::storage::cpp2::ResponseCommon>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + ListClusterInfoResp, + ::apache::thrift::type_class::structure, + ::nebula::cpp2::DirInfo>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + ListClusterInfoResp, + ::apache::thrift::type_class::structure, + ::nebula::storage::cpp2::ResponseCommon>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + ListClusterInfoResp, + ::apache::thrift::type_class::structure, + ::nebula::cpp2::DirInfo>, + "inconsistent use of nimble option"); + +}}} // nebula::storage::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::storage::cpp2::ListClusterInfoReq>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::storage::cpp2::ListClusterInfoReq>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace storage { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +ListClusterInfoReq::ListClusterInfoReq(apache::thrift::FragileConstructor) {} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void ListClusterInfoReq::__clear() { + // clear all fields +} + +bool ListClusterInfoReq::operator==(const ListClusterInfoReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + return true; +} + +bool ListClusterInfoReq::operator<(const ListClusterInfoReq& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + return false; +} + + +void swap(ListClusterInfoReq& a, ListClusterInfoReq& b) { + using ::std::swap; + (void)a; + (void)b; +} + +template void ListClusterInfoReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t ListClusterInfoReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t ListClusterInfoReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t ListClusterInfoReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void ListClusterInfoReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t ListClusterInfoReq::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t ListClusterInfoReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t ListClusterInfoReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::storage::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::storage::cpp2::KVGetRequest>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::storage::cpp2::KVGetRequest>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace storage { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +KVGetRequest::KVGetRequest(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector<::std::string>> parts__arg, bool return_partly__arg) : + space_id(std::move(space_id__arg)), + parts(std::move(parts__arg)), + return_partly(std::move(return_partly__arg)) { + __isset.space_id = true; + __isset.parts = true; + __isset.return_partly = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void KVGetRequest::__clear() { + // clear all fields + space_id = 0; + parts.clear(); + return_partly = 0; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool KVGetRequest::operator==(const KVGetRequest& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return false; + } + if (!(lhs.parts == rhs.parts)) { + return false; + } + if (!(lhs.return_partly == rhs.return_partly)) { + return false; + } + return true; +} + +const std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector<::std::string>>& KVGetRequest::get_parts() const& { + return parts; +} + +std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector<::std::string>> KVGetRequest::get_parts() && { + return std::move(parts); +} + + +void swap(KVGetRequest& a, KVGetRequest& b) { + using ::std::swap; + swap(a.space_id_ref().value(), b.space_id_ref().value()); + swap(a.parts_ref().value(), b.parts_ref().value()); + swap(a.return_partly_ref().value(), b.return_partly_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void KVGetRequest::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t KVGetRequest::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t KVGetRequest::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t KVGetRequest::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void KVGetRequest::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t KVGetRequest::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t KVGetRequest::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t KVGetRequest::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::storage::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::storage::cpp2::KVGetResponse>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::storage::cpp2::KVGetResponse>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace storage { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +KVGetResponse::KVGetResponse(apache::thrift::FragileConstructor, ::nebula::storage::cpp2::ResponseCommon result__arg, std::unordered_map<::std::string, ::std::string> key_values__arg) : + result(std::move(result__arg)), + key_values(std::move(key_values__arg)) { + __isset.key_values = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void KVGetResponse::__clear() { + // clear all fields + result.__clear(); + key_values.clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool KVGetResponse::operator==(const KVGetResponse& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.result == rhs.result)) { + return false; + } + if (!(lhs.key_values == rhs.key_values)) { + return false; + } + return true; +} + +const ::nebula::storage::cpp2::ResponseCommon& KVGetResponse::get_result() const& { + return result; +} + + ::nebula::storage::cpp2::ResponseCommon KVGetResponse::get_result() && { + return std::move(result); +} + +const std::unordered_map<::std::string, ::std::string>& KVGetResponse::get_key_values() const& { + return key_values; +} + +std::unordered_map<::std::string, ::std::string> KVGetResponse::get_key_values() && { + return std::move(key_values); +} + + +void swap(KVGetResponse& a, KVGetResponse& b) { + using ::std::swap; + swap(a.result_ref().value(), b.result_ref().value()); + swap(a.key_values_ref().value(), b.key_values_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void KVGetResponse::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t KVGetResponse::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t KVGetResponse::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t KVGetResponse::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void KVGetResponse::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t KVGetResponse::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t KVGetResponse::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t KVGetResponse::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + KVGetResponse, + ::apache::thrift::type_class::structure, + ::nebula::storage::cpp2::ResponseCommon>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + KVGetResponse, + ::apache::thrift::type_class::structure, + ::nebula::storage::cpp2::ResponseCommon>, + "inconsistent use of nimble option"); + +}}} // nebula::storage::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::storage::cpp2::KVPutRequest>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::storage::cpp2::KVPutRequest>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace storage { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +KVPutRequest::KVPutRequest(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector> parts__arg) : + space_id(std::move(space_id__arg)), + parts(std::move(parts__arg)) { + __isset.space_id = true; + __isset.parts = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void KVPutRequest::__clear() { + // clear all fields + space_id = 0; + parts.clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool KVPutRequest::operator==(const KVPutRequest& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return false; + } + if (!(lhs.parts == rhs.parts)) { + return false; + } + return true; +} + +const std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector>& KVPutRequest::get_parts() const& { + return parts; +} + +std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector> KVPutRequest::get_parts() && { + return std::move(parts); +} + + +void swap(KVPutRequest& a, KVPutRequest& b) { + using ::std::swap; + swap(a.space_id_ref().value(), b.space_id_ref().value()); + swap(a.parts_ref().value(), b.parts_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void KVPutRequest::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t KVPutRequest::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t KVPutRequest::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t KVPutRequest::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void KVPutRequest::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t KVPutRequest::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t KVPutRequest::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t KVPutRequest::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + KVPutRequest, + ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>>, + std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector>>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + KVPutRequest, + ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>>, + std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector>>, + "inconsistent use of nimble option"); + +}}} // nebula::storage::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::storage::cpp2::KVRemoveRequest>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::storage::cpp2::KVRemoveRequest>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace storage { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +KVRemoveRequest::KVRemoveRequest(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector<::std::string>> parts__arg) : + space_id(std::move(space_id__arg)), + parts(std::move(parts__arg)) { + __isset.space_id = true; + __isset.parts = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void KVRemoveRequest::__clear() { + // clear all fields + space_id = 0; + parts.clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool KVRemoveRequest::operator==(const KVRemoveRequest& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return false; + } + if (!(lhs.parts == rhs.parts)) { + return false; + } + return true; +} + +const std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector<::std::string>>& KVRemoveRequest::get_parts() const& { + return parts; +} + +std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector<::std::string>> KVRemoveRequest::get_parts() && { + return std::move(parts); +} + + +void swap(KVRemoveRequest& a, KVRemoveRequest& b) { + using ::std::swap; + swap(a.space_id_ref().value(), b.space_id_ref().value()); + swap(a.parts_ref().value(), b.parts_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void KVRemoveRequest::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t KVRemoveRequest::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t KVRemoveRequest::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t KVRemoveRequest::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void KVRemoveRequest::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t KVRemoveRequest::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t KVRemoveRequest::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t KVRemoveRequest::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + + + +}}} // nebula::storage::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::storage::cpp2::InternalTxnRequest>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::storage::cpp2::InternalTxnRequest>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace storage { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +InternalTxnRequest::InternalTxnRequest() : + txn_id(0) {} +THRIFT_IGNORE_ISSET_USE_WARNING_END + + +InternalTxnRequest::~InternalTxnRequest() {} + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +InternalTxnRequest::InternalTxnRequest(apache::thrift::FragileConstructor, int64_t txn_id__arg, ::std::map< ::nebula::cpp2::PartitionID, int64_t> term_of_parts__arg, ::nebula::storage::cpp2::AddEdgesRequest add_edge_req__arg, ::nebula::storage::cpp2::UpdateEdgeRequest upd_edge_req__arg, std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector> edge_ver__arg) : + txn_id(std::move(txn_id__arg)), + term_of_parts(std::move(term_of_parts__arg)), + add_edge_req(std::move(add_edge_req__arg)), + upd_edge_req(std::move(upd_edge_req__arg)), + edge_ver(std::move(edge_ver__arg)) { + __isset.txn_id = true; + __isset.term_of_parts = true; + __isset.add_edge_req = true; + __isset.upd_edge_req = true; + __isset.edge_ver = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void InternalTxnRequest::__clear() { + // clear all fields + txn_id = 0; + term_of_parts.clear(); + add_edge_req.__clear(); + upd_edge_req.__clear(); + edge_ver.clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool InternalTxnRequest::operator==(const InternalTxnRequest& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.txn_id == rhs.txn_id)) { + return false; + } + if (!(lhs.term_of_parts == rhs.term_of_parts)) { + return false; + } + if (lhs.add_edge_req_ref() != rhs.add_edge_req_ref()) { + return false; + } + if (lhs.upd_edge_req_ref() != rhs.upd_edge_req_ref()) { + return false; + } + if (lhs.edge_ver_ref() != rhs.edge_ver_ref()) { + return false; + } + return true; +} + +const ::std::map< ::nebula::cpp2::PartitionID, int64_t>& InternalTxnRequest::get_term_of_parts() const& { + return term_of_parts; +} + +::std::map< ::nebula::cpp2::PartitionID, int64_t> InternalTxnRequest::get_term_of_parts() && { + return std::move(term_of_parts); +} + +const ::nebula::storage::cpp2::AddEdgesRequest* InternalTxnRequest::get_add_edge_req() const& { + return add_edge_req_ref().has_value() ? std::addressof(add_edge_req) : nullptr; +} + + ::nebula::storage::cpp2::AddEdgesRequest* InternalTxnRequest::get_add_edge_req() & { + return add_edge_req_ref().has_value() ? std::addressof(add_edge_req) : nullptr; +} + +const ::nebula::storage::cpp2::UpdateEdgeRequest* InternalTxnRequest::get_upd_edge_req() const& { + return upd_edge_req_ref().has_value() ? std::addressof(upd_edge_req) : nullptr; +} + + ::nebula::storage::cpp2::UpdateEdgeRequest* InternalTxnRequest::get_upd_edge_req() & { + return upd_edge_req_ref().has_value() ? std::addressof(upd_edge_req) : nullptr; +} + +const std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector>* InternalTxnRequest::get_edge_ver() const& { + return edge_ver_ref().has_value() ? std::addressof(edge_ver) : nullptr; +} + +std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector>* InternalTxnRequest::get_edge_ver() & { + return edge_ver_ref().has_value() ? std::addressof(edge_ver) : nullptr; +} + + +void swap(InternalTxnRequest& a, InternalTxnRequest& b) { + using ::std::swap; + swap(a.txn_id_ref().value(), b.txn_id_ref().value()); + swap(a.term_of_parts_ref().value(), b.term_of_parts_ref().value()); + swap(a.add_edge_req_ref().value_unchecked(), b.add_edge_req_ref().value_unchecked()); + swap(a.upd_edge_req_ref().value_unchecked(), b.upd_edge_req_ref().value_unchecked()); + swap(a.edge_ver_ref().value_unchecked(), b.edge_ver_ref().value_unchecked()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void InternalTxnRequest::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t InternalTxnRequest::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t InternalTxnRequest::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t InternalTxnRequest::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void InternalTxnRequest::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t InternalTxnRequest::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t InternalTxnRequest::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t InternalTxnRequest::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + InternalTxnRequest, + ::apache::thrift::type_class::structure, + ::nebula::storage::cpp2::AddEdgesRequest>, + "inconsistent use of json option"); +static_assert( + ::apache::thrift::detail::st::gen_check_json< + InternalTxnRequest, + ::apache::thrift::type_class::structure, + ::nebula::storage::cpp2::UpdateEdgeRequest>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + InternalTxnRequest, + ::apache::thrift::type_class::structure, + ::nebula::storage::cpp2::AddEdgesRequest>, + "inconsistent use of nimble option"); +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + InternalTxnRequest, + ::apache::thrift::type_class::structure, + ::nebula::storage::cpp2::UpdateEdgeRequest>, + "inconsistent use of nimble option"); + +}}} // nebula::storage::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::storage::cpp2::ChainAddEdgesRequest>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::storage::cpp2::ChainAddEdgesRequest>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace storage { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +ChainAddEdgesRequest::ChainAddEdgesRequest() : + space_id(0), + if_not_exists(0), + term(0), + edge_version(0) {} +THRIFT_IGNORE_ISSET_USE_WARNING_END + + +ChainAddEdgesRequest::~ChainAddEdgesRequest() {} + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +ChainAddEdgesRequest::ChainAddEdgesRequest(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::storage::cpp2::NewEdge>> parts__arg, ::std::vector<::std::string> prop_names__arg, bool if_not_exists__arg, int64_t term__arg, int64_t edge_version__arg) : + space_id(std::move(space_id__arg)), + parts(std::move(parts__arg)), + prop_names(std::move(prop_names__arg)), + if_not_exists(std::move(if_not_exists__arg)), + term(std::move(term__arg)), + edge_version(std::move(edge_version__arg)) { + __isset.space_id = true; + __isset.parts = true; + __isset.prop_names = true; + __isset.if_not_exists = true; + __isset.term = true; + __isset.edge_version = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void ChainAddEdgesRequest::__clear() { + // clear all fields + space_id = 0; + parts.clear(); + prop_names.clear(); + if_not_exists = 0; + term = 0; + edge_version = 0; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool ChainAddEdgesRequest::operator==(const ChainAddEdgesRequest& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.space_id == rhs.space_id)) { + return false; + } + if (!(lhs.parts == rhs.parts)) { + return false; + } + if (!(lhs.prop_names == rhs.prop_names)) { + return false; + } + if (!(lhs.if_not_exists == rhs.if_not_exists)) { + return false; + } + if (!(lhs.term == rhs.term)) { + return false; + } + if (lhs.edge_version_ref() != rhs.edge_version_ref()) { + return false; + } + return true; +} + +const std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::storage::cpp2::NewEdge>>& ChainAddEdgesRequest::get_parts() const& { + return parts; +} + +std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::storage::cpp2::NewEdge>> ChainAddEdgesRequest::get_parts() && { + return std::move(parts); +} + +const ::std::vector<::std::string>& ChainAddEdgesRequest::get_prop_names() const& { + return prop_names; +} + +::std::vector<::std::string> ChainAddEdgesRequest::get_prop_names() && { + return std::move(prop_names); +} + + +void swap(ChainAddEdgesRequest& a, ChainAddEdgesRequest& b) { + using ::std::swap; + swap(a.space_id_ref().value(), b.space_id_ref().value()); + swap(a.parts_ref().value(), b.parts_ref().value()); + swap(a.prop_names_ref().value(), b.prop_names_ref().value()); + swap(a.if_not_exists_ref().value(), b.if_not_exists_ref().value()); + swap(a.term_ref().value(), b.term_ref().value()); + swap(a.edge_version_ref().value_unchecked(), b.edge_version_ref().value_unchecked()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void ChainAddEdgesRequest::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t ChainAddEdgesRequest::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t ChainAddEdgesRequest::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t ChainAddEdgesRequest::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void ChainAddEdgesRequest::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t ChainAddEdgesRequest::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t ChainAddEdgesRequest::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t ChainAddEdgesRequest::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + ChainAddEdgesRequest, + ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>>, + std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::storage::cpp2::NewEdge>>>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + ChainAddEdgesRequest, + ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>>, + std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::storage::cpp2::NewEdge>>>, + "inconsistent use of nimble option"); + +}}} // nebula::storage::cpp2 + +namespace apache { +namespace thrift { +namespace detail { + +void TccStructTraits<::nebula::storage::cpp2::ChainUpdateEdgeRequest>::translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept { + using data = apache::thrift::TStructDataStorage<::nebula::storage::cpp2::ChainUpdateEdgeRequest>; + static const st::translate_field_name_table table{ + data::fields_size, + data::fields_names.data(), + data::fields_ids.data(), + data::fields_types.data()}; + st::translate_field_name(_fname, fid, _ftype, table); +} + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace storage { namespace cpp2 { + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +ChainUpdateEdgeRequest::ChainUpdateEdgeRequest() : + term(0), + edge_version(0), + space_id(0) {} +THRIFT_IGNORE_ISSET_USE_WARNING_END + + +ChainUpdateEdgeRequest::~ChainUpdateEdgeRequest() {} + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN +ChainUpdateEdgeRequest::ChainUpdateEdgeRequest(apache::thrift::FragileConstructor, ::nebula::storage::cpp2::UpdateEdgeRequest update_edge_request__arg, int64_t term__arg, int64_t edge_version__arg, ::nebula::cpp2::GraphSpaceID space_id__arg, ::std::vector< ::nebula::cpp2::PartitionID> parts__arg) : + update_edge_request(std::move(update_edge_request__arg)), + term(std::move(term__arg)), + edge_version(std::move(edge_version__arg)), + space_id(std::move(space_id__arg)), + parts(std::move(parts__arg)) { + __isset.update_edge_request = true; + __isset.term = true; + __isset.edge_version = true; + __isset.space_id = true; +} +THRIFT_IGNORE_ISSET_USE_WARNING_END +void ChainUpdateEdgeRequest::__clear() { + // clear all fields + update_edge_request.__clear(); + term = 0; + edge_version = 0; + space_id = 0; + parts.clear(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset = {}; +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +bool ChainUpdateEdgeRequest::operator==(const ChainUpdateEdgeRequest& rhs) const { + (void)rhs; + auto& lhs = *this; + (void)lhs; + if (!(lhs.update_edge_request == rhs.update_edge_request)) { + return false; + } + if (!(lhs.term == rhs.term)) { + return false; + } + if (lhs.edge_version_ref() != rhs.edge_version_ref()) { + return false; + } + if (!(lhs.space_id == rhs.space_id)) { + return false; + } + if (!(lhs.parts == rhs.parts)) { + return false; + } + return true; +} + +const ::nebula::storage::cpp2::UpdateEdgeRequest& ChainUpdateEdgeRequest::get_update_edge_request() const& { + return update_edge_request; +} + + ::nebula::storage::cpp2::UpdateEdgeRequest ChainUpdateEdgeRequest::get_update_edge_request() && { + return std::move(update_edge_request); +} + +const ::std::vector< ::nebula::cpp2::PartitionID>& ChainUpdateEdgeRequest::get_parts() const& { + return parts; +} + +::std::vector< ::nebula::cpp2::PartitionID> ChainUpdateEdgeRequest::get_parts() && { + return std::move(parts); +} + + +void swap(ChainUpdateEdgeRequest& a, ChainUpdateEdgeRequest& b) { + using ::std::swap; + swap(a.update_edge_request_ref().value(), b.update_edge_request_ref().value()); + swap(a.term_ref().value(), b.term_ref().value()); + swap(a.edge_version_ref().value_unchecked(), b.edge_version_ref().value_unchecked()); + swap(a.space_id_ref().value(), b.space_id_ref().value()); + swap(a.parts_ref().value(), b.parts_ref().value()); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + swap(a.__isset, b.__isset); +THRIFT_IGNORE_ISSET_USE_WARNING_END +} + +template void ChainUpdateEdgeRequest::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +template uint32_t ChainUpdateEdgeRequest::write<>(apache::thrift::BinaryProtocolWriter*) const; +template uint32_t ChainUpdateEdgeRequest::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +template uint32_t ChainUpdateEdgeRequest::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +template void ChainUpdateEdgeRequest::readNoXfer<>(apache::thrift::CompactProtocolReader*); +template uint32_t ChainUpdateEdgeRequest::write<>(apache::thrift::CompactProtocolWriter*) const; +template uint32_t ChainUpdateEdgeRequest::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +template uint32_t ChainUpdateEdgeRequest::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +static_assert( + ::apache::thrift::detail::st::gen_check_json< + ChainUpdateEdgeRequest, + ::apache::thrift::type_class::structure, + ::nebula::storage::cpp2::UpdateEdgeRequest>, + "inconsistent use of json option"); + +static_assert( + ::apache::thrift::detail::st::gen_check_nimble< + ChainUpdateEdgeRequest, + ::apache::thrift::type_class::structure, + ::nebula::storage::cpp2::UpdateEdgeRequest>, + "inconsistent use of nimble option"); + +}}} // nebula::storage::cpp2 diff --git a/src/interface/gen-cpp2/storage_types.h b/src/interface/gen-cpp2/storage_types.h new file mode 100644 index 00000000..530516a4 --- /dev/null +++ b/src/interface/gen-cpp2/storage_types.h @@ -0,0 +1,15765 @@ +/** + * Autogenerated by Thrift for storage.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#pragma once + +#include + + +#include "common_types.h" +#include "meta_types.h" + +namespace apache { +namespace thrift { +namespace tag { +struct session_id; +struct plan_id; +struct profile_detail; +struct code; +struct part_id; +struct leader; +struct failed_parts; +struct latency_in_us; +struct latency_detail_us; +struct alias; +struct prop; +struct stat; +struct alias; +struct expr; +struct type; +struct props; +struct tag; +struct props; +struct prop; +struct direction; +struct edge_types; +struct edge_direction; +struct dedup; +struct stat_props; +struct vertex_props; +struct edge_props; +struct expressions; +struct order_by; +struct random; +struct limit; +struct filter; +struct space_id; +struct column_names; +struct parts; +struct traverse_spec; +struct common; +struct result; +struct vertices; +struct result; +struct space_id; +struct parts; +struct vertex_props; +struct edge_props; +struct expressions; +struct dedup; +struct order_by; +struct limit; +struct filter; +struct common; +struct result; +struct props; +struct tag_id; +struct props; +struct id; +struct tags; +struct src; +struct edge_type; +struct ranking; +struct dst; +struct key; +struct props; +struct space_id; +struct parts; +struct prop_names; +struct if_not_exists; +struct common; +struct space_id; +struct parts; +struct prop_names; +struct if_not_exists; +struct common; +struct space_id; +struct parts; +struct common; +struct space_id; +struct parts; +struct common; +struct id; +struct tags; +struct space_id; +struct parts; +struct common; +struct result; +struct props; +struct name; +struct value; +struct space_id; +struct part_id; +struct vertex_id; +struct tag_id; +struct updated_props; +struct insertable; +struct return_props; +struct condition; +struct common; +struct space_id; +struct part_id; +struct edge_key; +struct updated_props; +struct insertable; +struct return_props; +struct condition; +struct common; +struct space_id; +struct part_id; +struct name; +struct common; +struct result; +struct id; +struct result; +struct data; +struct column_name; +struct scan_type; +struct begin_value; +struct end_value; +struct index_id; +struct filter; +struct column_hints; +struct contexts; +struct schema_id; +struct space_id; +struct parts; +struct indices; +struct return_columns; +struct common; +struct limit; +struct space_id; +struct parts; +struct indices; +struct traverse_spec; +struct common; +struct space_id; +struct part_id; +struct cursor; +struct return_columns; +struct limit; +struct start_time; +struct end_time; +struct filter; +struct only_latest_version; +struct enable_read_from_follower; +struct common; +struct result; +struct vertex_data; +struct has_next; +struct next_cursor; +struct space_id; +struct part_id; +struct cursor; +struct return_columns; +struct limit; +struct start_time; +struct end_time; +struct filter; +struct only_latest_version; +struct enable_read_from_follower; +struct common; +struct result; +struct edge_data; +struct has_next; +struct next_cursor; +struct space_id; +struct parts; +struct task_specfic_paras; +struct cmd; +struct job_id; +struct task_id; +struct para; +struct concurrency; +struct job_id; +struct task_id; +struct result; +struct stats; +struct space_id; +struct part_id; +struct new_leader; +struct space_id; +struct part_id; +struct as_learner; +struct peers; +struct space_id; +struct part_id; +struct learner; +struct space_id; +struct part_id; +struct space_id; +struct part_id; +struct peer; +struct add; +struct space_id; +struct part_id; +struct target; +struct space_id; +struct name; +struct space_id; +struct name; +struct space_id; +struct sign; +struct result; +struct leader_parts; +struct space_id; +struct part_id; +struct peers; +struct space_id; +struct parts; +struct index_id; +struct result; +struct info; +struct result; +struct dir; +struct space_id; +struct parts; +struct return_partly; +struct result; +struct key_values; +struct space_id; +struct parts; +struct space_id; +struct parts; +struct txn_id; +struct term_of_parts; +struct add_edge_req; +struct upd_edge_req; +struct edge_ver; +struct space_id; +struct parts; +struct prop_names; +struct if_not_exists; +struct term; +struct edge_version; +struct update_edge_request; +struct term; +struct edge_version; +struct space_id; +struct parts; +} // namespace tag +namespace detail { +#ifndef APACHE_THRIFT_ACCESSOR_session_id +#define APACHE_THRIFT_ACCESSOR_session_id +APACHE_THRIFT_DEFINE_ACCESSOR(session_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_plan_id +#define APACHE_THRIFT_ACCESSOR_plan_id +APACHE_THRIFT_DEFINE_ACCESSOR(plan_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_profile_detail +#define APACHE_THRIFT_ACCESSOR_profile_detail +APACHE_THRIFT_DEFINE_ACCESSOR(profile_detail); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_code +#define APACHE_THRIFT_ACCESSOR_code +APACHE_THRIFT_DEFINE_ACCESSOR(code); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_part_id +#define APACHE_THRIFT_ACCESSOR_part_id +APACHE_THRIFT_DEFINE_ACCESSOR(part_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_leader +#define APACHE_THRIFT_ACCESSOR_leader +APACHE_THRIFT_DEFINE_ACCESSOR(leader); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_failed_parts +#define APACHE_THRIFT_ACCESSOR_failed_parts +APACHE_THRIFT_DEFINE_ACCESSOR(failed_parts); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_latency_in_us +#define APACHE_THRIFT_ACCESSOR_latency_in_us +APACHE_THRIFT_DEFINE_ACCESSOR(latency_in_us); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_latency_detail_us +#define APACHE_THRIFT_ACCESSOR_latency_detail_us +APACHE_THRIFT_DEFINE_ACCESSOR(latency_detail_us); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_alias +#define APACHE_THRIFT_ACCESSOR_alias +APACHE_THRIFT_DEFINE_ACCESSOR(alias); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_prop +#define APACHE_THRIFT_ACCESSOR_prop +APACHE_THRIFT_DEFINE_ACCESSOR(prop); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_stat +#define APACHE_THRIFT_ACCESSOR_stat +APACHE_THRIFT_DEFINE_ACCESSOR(stat); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_alias +#define APACHE_THRIFT_ACCESSOR_alias +APACHE_THRIFT_DEFINE_ACCESSOR(alias); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_expr +#define APACHE_THRIFT_ACCESSOR_expr +APACHE_THRIFT_DEFINE_ACCESSOR(expr); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_type +#define APACHE_THRIFT_ACCESSOR_type +APACHE_THRIFT_DEFINE_ACCESSOR(type); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_props +#define APACHE_THRIFT_ACCESSOR_props +APACHE_THRIFT_DEFINE_ACCESSOR(props); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_tag +#define APACHE_THRIFT_ACCESSOR_tag +APACHE_THRIFT_DEFINE_ACCESSOR(tag); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_props +#define APACHE_THRIFT_ACCESSOR_props +APACHE_THRIFT_DEFINE_ACCESSOR(props); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_prop +#define APACHE_THRIFT_ACCESSOR_prop +APACHE_THRIFT_DEFINE_ACCESSOR(prop); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_direction +#define APACHE_THRIFT_ACCESSOR_direction +APACHE_THRIFT_DEFINE_ACCESSOR(direction); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_edge_types +#define APACHE_THRIFT_ACCESSOR_edge_types +APACHE_THRIFT_DEFINE_ACCESSOR(edge_types); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_edge_direction +#define APACHE_THRIFT_ACCESSOR_edge_direction +APACHE_THRIFT_DEFINE_ACCESSOR(edge_direction); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_dedup +#define APACHE_THRIFT_ACCESSOR_dedup +APACHE_THRIFT_DEFINE_ACCESSOR(dedup); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_stat_props +#define APACHE_THRIFT_ACCESSOR_stat_props +APACHE_THRIFT_DEFINE_ACCESSOR(stat_props); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_vertex_props +#define APACHE_THRIFT_ACCESSOR_vertex_props +APACHE_THRIFT_DEFINE_ACCESSOR(vertex_props); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_edge_props +#define APACHE_THRIFT_ACCESSOR_edge_props +APACHE_THRIFT_DEFINE_ACCESSOR(edge_props); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_expressions +#define APACHE_THRIFT_ACCESSOR_expressions +APACHE_THRIFT_DEFINE_ACCESSOR(expressions); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_order_by +#define APACHE_THRIFT_ACCESSOR_order_by +APACHE_THRIFT_DEFINE_ACCESSOR(order_by); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_random +#define APACHE_THRIFT_ACCESSOR_random +APACHE_THRIFT_DEFINE_ACCESSOR(random); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_limit +#define APACHE_THRIFT_ACCESSOR_limit +APACHE_THRIFT_DEFINE_ACCESSOR(limit); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_filter +#define APACHE_THRIFT_ACCESSOR_filter +APACHE_THRIFT_DEFINE_ACCESSOR(filter); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_space_id +#define APACHE_THRIFT_ACCESSOR_space_id +APACHE_THRIFT_DEFINE_ACCESSOR(space_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_column_names +#define APACHE_THRIFT_ACCESSOR_column_names +APACHE_THRIFT_DEFINE_ACCESSOR(column_names); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_parts +#define APACHE_THRIFT_ACCESSOR_parts +APACHE_THRIFT_DEFINE_ACCESSOR(parts); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_traverse_spec +#define APACHE_THRIFT_ACCESSOR_traverse_spec +APACHE_THRIFT_DEFINE_ACCESSOR(traverse_spec); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_common +#define APACHE_THRIFT_ACCESSOR_common +APACHE_THRIFT_DEFINE_ACCESSOR(common); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_result +#define APACHE_THRIFT_ACCESSOR_result +APACHE_THRIFT_DEFINE_ACCESSOR(result); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_vertices +#define APACHE_THRIFT_ACCESSOR_vertices +APACHE_THRIFT_DEFINE_ACCESSOR(vertices); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_result +#define APACHE_THRIFT_ACCESSOR_result +APACHE_THRIFT_DEFINE_ACCESSOR(result); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_space_id +#define APACHE_THRIFT_ACCESSOR_space_id +APACHE_THRIFT_DEFINE_ACCESSOR(space_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_parts +#define APACHE_THRIFT_ACCESSOR_parts +APACHE_THRIFT_DEFINE_ACCESSOR(parts); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_vertex_props +#define APACHE_THRIFT_ACCESSOR_vertex_props +APACHE_THRIFT_DEFINE_ACCESSOR(vertex_props); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_edge_props +#define APACHE_THRIFT_ACCESSOR_edge_props +APACHE_THRIFT_DEFINE_ACCESSOR(edge_props); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_expressions +#define APACHE_THRIFT_ACCESSOR_expressions +APACHE_THRIFT_DEFINE_ACCESSOR(expressions); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_dedup +#define APACHE_THRIFT_ACCESSOR_dedup +APACHE_THRIFT_DEFINE_ACCESSOR(dedup); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_order_by +#define APACHE_THRIFT_ACCESSOR_order_by +APACHE_THRIFT_DEFINE_ACCESSOR(order_by); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_limit +#define APACHE_THRIFT_ACCESSOR_limit +APACHE_THRIFT_DEFINE_ACCESSOR(limit); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_filter +#define APACHE_THRIFT_ACCESSOR_filter +APACHE_THRIFT_DEFINE_ACCESSOR(filter); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_common +#define APACHE_THRIFT_ACCESSOR_common +APACHE_THRIFT_DEFINE_ACCESSOR(common); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_result +#define APACHE_THRIFT_ACCESSOR_result +APACHE_THRIFT_DEFINE_ACCESSOR(result); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_props +#define APACHE_THRIFT_ACCESSOR_props +APACHE_THRIFT_DEFINE_ACCESSOR(props); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_tag_id +#define APACHE_THRIFT_ACCESSOR_tag_id +APACHE_THRIFT_DEFINE_ACCESSOR(tag_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_props +#define APACHE_THRIFT_ACCESSOR_props +APACHE_THRIFT_DEFINE_ACCESSOR(props); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_id +#define APACHE_THRIFT_ACCESSOR_id +APACHE_THRIFT_DEFINE_ACCESSOR(id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_tags +#define APACHE_THRIFT_ACCESSOR_tags +APACHE_THRIFT_DEFINE_ACCESSOR(tags); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_src +#define APACHE_THRIFT_ACCESSOR_src +APACHE_THRIFT_DEFINE_ACCESSOR(src); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_edge_type +#define APACHE_THRIFT_ACCESSOR_edge_type +APACHE_THRIFT_DEFINE_ACCESSOR(edge_type); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_ranking +#define APACHE_THRIFT_ACCESSOR_ranking +APACHE_THRIFT_DEFINE_ACCESSOR(ranking); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_dst +#define APACHE_THRIFT_ACCESSOR_dst +APACHE_THRIFT_DEFINE_ACCESSOR(dst); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_key +#define APACHE_THRIFT_ACCESSOR_key +APACHE_THRIFT_DEFINE_ACCESSOR(key); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_props +#define APACHE_THRIFT_ACCESSOR_props +APACHE_THRIFT_DEFINE_ACCESSOR(props); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_space_id +#define APACHE_THRIFT_ACCESSOR_space_id +APACHE_THRIFT_DEFINE_ACCESSOR(space_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_parts +#define APACHE_THRIFT_ACCESSOR_parts +APACHE_THRIFT_DEFINE_ACCESSOR(parts); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_prop_names +#define APACHE_THRIFT_ACCESSOR_prop_names +APACHE_THRIFT_DEFINE_ACCESSOR(prop_names); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_if_not_exists +#define APACHE_THRIFT_ACCESSOR_if_not_exists +APACHE_THRIFT_DEFINE_ACCESSOR(if_not_exists); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_common +#define APACHE_THRIFT_ACCESSOR_common +APACHE_THRIFT_DEFINE_ACCESSOR(common); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_space_id +#define APACHE_THRIFT_ACCESSOR_space_id +APACHE_THRIFT_DEFINE_ACCESSOR(space_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_parts +#define APACHE_THRIFT_ACCESSOR_parts +APACHE_THRIFT_DEFINE_ACCESSOR(parts); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_prop_names +#define APACHE_THRIFT_ACCESSOR_prop_names +APACHE_THRIFT_DEFINE_ACCESSOR(prop_names); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_if_not_exists +#define APACHE_THRIFT_ACCESSOR_if_not_exists +APACHE_THRIFT_DEFINE_ACCESSOR(if_not_exists); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_common +#define APACHE_THRIFT_ACCESSOR_common +APACHE_THRIFT_DEFINE_ACCESSOR(common); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_space_id +#define APACHE_THRIFT_ACCESSOR_space_id +APACHE_THRIFT_DEFINE_ACCESSOR(space_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_parts +#define APACHE_THRIFT_ACCESSOR_parts +APACHE_THRIFT_DEFINE_ACCESSOR(parts); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_common +#define APACHE_THRIFT_ACCESSOR_common +APACHE_THRIFT_DEFINE_ACCESSOR(common); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_space_id +#define APACHE_THRIFT_ACCESSOR_space_id +APACHE_THRIFT_DEFINE_ACCESSOR(space_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_parts +#define APACHE_THRIFT_ACCESSOR_parts +APACHE_THRIFT_DEFINE_ACCESSOR(parts); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_common +#define APACHE_THRIFT_ACCESSOR_common +APACHE_THRIFT_DEFINE_ACCESSOR(common); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_id +#define APACHE_THRIFT_ACCESSOR_id +APACHE_THRIFT_DEFINE_ACCESSOR(id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_tags +#define APACHE_THRIFT_ACCESSOR_tags +APACHE_THRIFT_DEFINE_ACCESSOR(tags); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_space_id +#define APACHE_THRIFT_ACCESSOR_space_id +APACHE_THRIFT_DEFINE_ACCESSOR(space_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_parts +#define APACHE_THRIFT_ACCESSOR_parts +APACHE_THRIFT_DEFINE_ACCESSOR(parts); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_common +#define APACHE_THRIFT_ACCESSOR_common +APACHE_THRIFT_DEFINE_ACCESSOR(common); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_result +#define APACHE_THRIFT_ACCESSOR_result +APACHE_THRIFT_DEFINE_ACCESSOR(result); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_props +#define APACHE_THRIFT_ACCESSOR_props +APACHE_THRIFT_DEFINE_ACCESSOR(props); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_name +#define APACHE_THRIFT_ACCESSOR_name +APACHE_THRIFT_DEFINE_ACCESSOR(name); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_value +#define APACHE_THRIFT_ACCESSOR_value +APACHE_THRIFT_DEFINE_ACCESSOR(value); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_space_id +#define APACHE_THRIFT_ACCESSOR_space_id +APACHE_THRIFT_DEFINE_ACCESSOR(space_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_part_id +#define APACHE_THRIFT_ACCESSOR_part_id +APACHE_THRIFT_DEFINE_ACCESSOR(part_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_vertex_id +#define APACHE_THRIFT_ACCESSOR_vertex_id +APACHE_THRIFT_DEFINE_ACCESSOR(vertex_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_tag_id +#define APACHE_THRIFT_ACCESSOR_tag_id +APACHE_THRIFT_DEFINE_ACCESSOR(tag_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_updated_props +#define APACHE_THRIFT_ACCESSOR_updated_props +APACHE_THRIFT_DEFINE_ACCESSOR(updated_props); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_insertable +#define APACHE_THRIFT_ACCESSOR_insertable +APACHE_THRIFT_DEFINE_ACCESSOR(insertable); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_return_props +#define APACHE_THRIFT_ACCESSOR_return_props +APACHE_THRIFT_DEFINE_ACCESSOR(return_props); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_condition +#define APACHE_THRIFT_ACCESSOR_condition +APACHE_THRIFT_DEFINE_ACCESSOR(condition); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_common +#define APACHE_THRIFT_ACCESSOR_common +APACHE_THRIFT_DEFINE_ACCESSOR(common); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_space_id +#define APACHE_THRIFT_ACCESSOR_space_id +APACHE_THRIFT_DEFINE_ACCESSOR(space_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_part_id +#define APACHE_THRIFT_ACCESSOR_part_id +APACHE_THRIFT_DEFINE_ACCESSOR(part_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_edge_key +#define APACHE_THRIFT_ACCESSOR_edge_key +APACHE_THRIFT_DEFINE_ACCESSOR(edge_key); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_updated_props +#define APACHE_THRIFT_ACCESSOR_updated_props +APACHE_THRIFT_DEFINE_ACCESSOR(updated_props); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_insertable +#define APACHE_THRIFT_ACCESSOR_insertable +APACHE_THRIFT_DEFINE_ACCESSOR(insertable); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_return_props +#define APACHE_THRIFT_ACCESSOR_return_props +APACHE_THRIFT_DEFINE_ACCESSOR(return_props); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_condition +#define APACHE_THRIFT_ACCESSOR_condition +APACHE_THRIFT_DEFINE_ACCESSOR(condition); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_common +#define APACHE_THRIFT_ACCESSOR_common +APACHE_THRIFT_DEFINE_ACCESSOR(common); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_space_id +#define APACHE_THRIFT_ACCESSOR_space_id +APACHE_THRIFT_DEFINE_ACCESSOR(space_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_part_id +#define APACHE_THRIFT_ACCESSOR_part_id +APACHE_THRIFT_DEFINE_ACCESSOR(part_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_name +#define APACHE_THRIFT_ACCESSOR_name +APACHE_THRIFT_DEFINE_ACCESSOR(name); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_common +#define APACHE_THRIFT_ACCESSOR_common +APACHE_THRIFT_DEFINE_ACCESSOR(common); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_result +#define APACHE_THRIFT_ACCESSOR_result +APACHE_THRIFT_DEFINE_ACCESSOR(result); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_id +#define APACHE_THRIFT_ACCESSOR_id +APACHE_THRIFT_DEFINE_ACCESSOR(id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_result +#define APACHE_THRIFT_ACCESSOR_result +APACHE_THRIFT_DEFINE_ACCESSOR(result); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_data +#define APACHE_THRIFT_ACCESSOR_data +APACHE_THRIFT_DEFINE_ACCESSOR(data); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_column_name +#define APACHE_THRIFT_ACCESSOR_column_name +APACHE_THRIFT_DEFINE_ACCESSOR(column_name); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_scan_type +#define APACHE_THRIFT_ACCESSOR_scan_type +APACHE_THRIFT_DEFINE_ACCESSOR(scan_type); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_begin_value +#define APACHE_THRIFT_ACCESSOR_begin_value +APACHE_THRIFT_DEFINE_ACCESSOR(begin_value); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_end_value +#define APACHE_THRIFT_ACCESSOR_end_value +APACHE_THRIFT_DEFINE_ACCESSOR(end_value); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_index_id +#define APACHE_THRIFT_ACCESSOR_index_id +APACHE_THRIFT_DEFINE_ACCESSOR(index_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_filter +#define APACHE_THRIFT_ACCESSOR_filter +APACHE_THRIFT_DEFINE_ACCESSOR(filter); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_column_hints +#define APACHE_THRIFT_ACCESSOR_column_hints +APACHE_THRIFT_DEFINE_ACCESSOR(column_hints); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_contexts +#define APACHE_THRIFT_ACCESSOR_contexts +APACHE_THRIFT_DEFINE_ACCESSOR(contexts); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_schema_id +#define APACHE_THRIFT_ACCESSOR_schema_id +APACHE_THRIFT_DEFINE_ACCESSOR(schema_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_space_id +#define APACHE_THRIFT_ACCESSOR_space_id +APACHE_THRIFT_DEFINE_ACCESSOR(space_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_parts +#define APACHE_THRIFT_ACCESSOR_parts +APACHE_THRIFT_DEFINE_ACCESSOR(parts); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_indices +#define APACHE_THRIFT_ACCESSOR_indices +APACHE_THRIFT_DEFINE_ACCESSOR(indices); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_return_columns +#define APACHE_THRIFT_ACCESSOR_return_columns +APACHE_THRIFT_DEFINE_ACCESSOR(return_columns); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_common +#define APACHE_THRIFT_ACCESSOR_common +APACHE_THRIFT_DEFINE_ACCESSOR(common); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_limit +#define APACHE_THRIFT_ACCESSOR_limit +APACHE_THRIFT_DEFINE_ACCESSOR(limit); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_space_id +#define APACHE_THRIFT_ACCESSOR_space_id +APACHE_THRIFT_DEFINE_ACCESSOR(space_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_parts +#define APACHE_THRIFT_ACCESSOR_parts +APACHE_THRIFT_DEFINE_ACCESSOR(parts); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_indices +#define APACHE_THRIFT_ACCESSOR_indices +APACHE_THRIFT_DEFINE_ACCESSOR(indices); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_traverse_spec +#define APACHE_THRIFT_ACCESSOR_traverse_spec +APACHE_THRIFT_DEFINE_ACCESSOR(traverse_spec); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_common +#define APACHE_THRIFT_ACCESSOR_common +APACHE_THRIFT_DEFINE_ACCESSOR(common); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_space_id +#define APACHE_THRIFT_ACCESSOR_space_id +APACHE_THRIFT_DEFINE_ACCESSOR(space_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_part_id +#define APACHE_THRIFT_ACCESSOR_part_id +APACHE_THRIFT_DEFINE_ACCESSOR(part_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_cursor +#define APACHE_THRIFT_ACCESSOR_cursor +APACHE_THRIFT_DEFINE_ACCESSOR(cursor); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_return_columns +#define APACHE_THRIFT_ACCESSOR_return_columns +APACHE_THRIFT_DEFINE_ACCESSOR(return_columns); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_limit +#define APACHE_THRIFT_ACCESSOR_limit +APACHE_THRIFT_DEFINE_ACCESSOR(limit); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_start_time +#define APACHE_THRIFT_ACCESSOR_start_time +APACHE_THRIFT_DEFINE_ACCESSOR(start_time); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_end_time +#define APACHE_THRIFT_ACCESSOR_end_time +APACHE_THRIFT_DEFINE_ACCESSOR(end_time); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_filter +#define APACHE_THRIFT_ACCESSOR_filter +APACHE_THRIFT_DEFINE_ACCESSOR(filter); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_only_latest_version +#define APACHE_THRIFT_ACCESSOR_only_latest_version +APACHE_THRIFT_DEFINE_ACCESSOR(only_latest_version); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_enable_read_from_follower +#define APACHE_THRIFT_ACCESSOR_enable_read_from_follower +APACHE_THRIFT_DEFINE_ACCESSOR(enable_read_from_follower); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_common +#define APACHE_THRIFT_ACCESSOR_common +APACHE_THRIFT_DEFINE_ACCESSOR(common); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_result +#define APACHE_THRIFT_ACCESSOR_result +APACHE_THRIFT_DEFINE_ACCESSOR(result); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_vertex_data +#define APACHE_THRIFT_ACCESSOR_vertex_data +APACHE_THRIFT_DEFINE_ACCESSOR(vertex_data); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_has_next +#define APACHE_THRIFT_ACCESSOR_has_next +APACHE_THRIFT_DEFINE_ACCESSOR(has_next); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_next_cursor +#define APACHE_THRIFT_ACCESSOR_next_cursor +APACHE_THRIFT_DEFINE_ACCESSOR(next_cursor); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_space_id +#define APACHE_THRIFT_ACCESSOR_space_id +APACHE_THRIFT_DEFINE_ACCESSOR(space_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_part_id +#define APACHE_THRIFT_ACCESSOR_part_id +APACHE_THRIFT_DEFINE_ACCESSOR(part_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_cursor +#define APACHE_THRIFT_ACCESSOR_cursor +APACHE_THRIFT_DEFINE_ACCESSOR(cursor); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_return_columns +#define APACHE_THRIFT_ACCESSOR_return_columns +APACHE_THRIFT_DEFINE_ACCESSOR(return_columns); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_limit +#define APACHE_THRIFT_ACCESSOR_limit +APACHE_THRIFT_DEFINE_ACCESSOR(limit); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_start_time +#define APACHE_THRIFT_ACCESSOR_start_time +APACHE_THRIFT_DEFINE_ACCESSOR(start_time); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_end_time +#define APACHE_THRIFT_ACCESSOR_end_time +APACHE_THRIFT_DEFINE_ACCESSOR(end_time); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_filter +#define APACHE_THRIFT_ACCESSOR_filter +APACHE_THRIFT_DEFINE_ACCESSOR(filter); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_only_latest_version +#define APACHE_THRIFT_ACCESSOR_only_latest_version +APACHE_THRIFT_DEFINE_ACCESSOR(only_latest_version); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_enable_read_from_follower +#define APACHE_THRIFT_ACCESSOR_enable_read_from_follower +APACHE_THRIFT_DEFINE_ACCESSOR(enable_read_from_follower); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_common +#define APACHE_THRIFT_ACCESSOR_common +APACHE_THRIFT_DEFINE_ACCESSOR(common); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_result +#define APACHE_THRIFT_ACCESSOR_result +APACHE_THRIFT_DEFINE_ACCESSOR(result); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_edge_data +#define APACHE_THRIFT_ACCESSOR_edge_data +APACHE_THRIFT_DEFINE_ACCESSOR(edge_data); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_has_next +#define APACHE_THRIFT_ACCESSOR_has_next +APACHE_THRIFT_DEFINE_ACCESSOR(has_next); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_next_cursor +#define APACHE_THRIFT_ACCESSOR_next_cursor +APACHE_THRIFT_DEFINE_ACCESSOR(next_cursor); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_space_id +#define APACHE_THRIFT_ACCESSOR_space_id +APACHE_THRIFT_DEFINE_ACCESSOR(space_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_parts +#define APACHE_THRIFT_ACCESSOR_parts +APACHE_THRIFT_DEFINE_ACCESSOR(parts); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_task_specfic_paras +#define APACHE_THRIFT_ACCESSOR_task_specfic_paras +APACHE_THRIFT_DEFINE_ACCESSOR(task_specfic_paras); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_cmd +#define APACHE_THRIFT_ACCESSOR_cmd +APACHE_THRIFT_DEFINE_ACCESSOR(cmd); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_job_id +#define APACHE_THRIFT_ACCESSOR_job_id +APACHE_THRIFT_DEFINE_ACCESSOR(job_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_task_id +#define APACHE_THRIFT_ACCESSOR_task_id +APACHE_THRIFT_DEFINE_ACCESSOR(task_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_para +#define APACHE_THRIFT_ACCESSOR_para +APACHE_THRIFT_DEFINE_ACCESSOR(para); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_concurrency +#define APACHE_THRIFT_ACCESSOR_concurrency +APACHE_THRIFT_DEFINE_ACCESSOR(concurrency); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_job_id +#define APACHE_THRIFT_ACCESSOR_job_id +APACHE_THRIFT_DEFINE_ACCESSOR(job_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_task_id +#define APACHE_THRIFT_ACCESSOR_task_id +APACHE_THRIFT_DEFINE_ACCESSOR(task_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_result +#define APACHE_THRIFT_ACCESSOR_result +APACHE_THRIFT_DEFINE_ACCESSOR(result); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_stats +#define APACHE_THRIFT_ACCESSOR_stats +APACHE_THRIFT_DEFINE_ACCESSOR(stats); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_space_id +#define APACHE_THRIFT_ACCESSOR_space_id +APACHE_THRIFT_DEFINE_ACCESSOR(space_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_part_id +#define APACHE_THRIFT_ACCESSOR_part_id +APACHE_THRIFT_DEFINE_ACCESSOR(part_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_new_leader +#define APACHE_THRIFT_ACCESSOR_new_leader +APACHE_THRIFT_DEFINE_ACCESSOR(new_leader); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_space_id +#define APACHE_THRIFT_ACCESSOR_space_id +APACHE_THRIFT_DEFINE_ACCESSOR(space_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_part_id +#define APACHE_THRIFT_ACCESSOR_part_id +APACHE_THRIFT_DEFINE_ACCESSOR(part_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_as_learner +#define APACHE_THRIFT_ACCESSOR_as_learner +APACHE_THRIFT_DEFINE_ACCESSOR(as_learner); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_peers +#define APACHE_THRIFT_ACCESSOR_peers +APACHE_THRIFT_DEFINE_ACCESSOR(peers); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_space_id +#define APACHE_THRIFT_ACCESSOR_space_id +APACHE_THRIFT_DEFINE_ACCESSOR(space_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_part_id +#define APACHE_THRIFT_ACCESSOR_part_id +APACHE_THRIFT_DEFINE_ACCESSOR(part_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_learner +#define APACHE_THRIFT_ACCESSOR_learner +APACHE_THRIFT_DEFINE_ACCESSOR(learner); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_space_id +#define APACHE_THRIFT_ACCESSOR_space_id +APACHE_THRIFT_DEFINE_ACCESSOR(space_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_part_id +#define APACHE_THRIFT_ACCESSOR_part_id +APACHE_THRIFT_DEFINE_ACCESSOR(part_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_space_id +#define APACHE_THRIFT_ACCESSOR_space_id +APACHE_THRIFT_DEFINE_ACCESSOR(space_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_part_id +#define APACHE_THRIFT_ACCESSOR_part_id +APACHE_THRIFT_DEFINE_ACCESSOR(part_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_peer +#define APACHE_THRIFT_ACCESSOR_peer +APACHE_THRIFT_DEFINE_ACCESSOR(peer); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_add +#define APACHE_THRIFT_ACCESSOR_add +APACHE_THRIFT_DEFINE_ACCESSOR(add); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_space_id +#define APACHE_THRIFT_ACCESSOR_space_id +APACHE_THRIFT_DEFINE_ACCESSOR(space_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_part_id +#define APACHE_THRIFT_ACCESSOR_part_id +APACHE_THRIFT_DEFINE_ACCESSOR(part_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_target +#define APACHE_THRIFT_ACCESSOR_target +APACHE_THRIFT_DEFINE_ACCESSOR(target); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_space_id +#define APACHE_THRIFT_ACCESSOR_space_id +APACHE_THRIFT_DEFINE_ACCESSOR(space_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_name +#define APACHE_THRIFT_ACCESSOR_name +APACHE_THRIFT_DEFINE_ACCESSOR(name); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_space_id +#define APACHE_THRIFT_ACCESSOR_space_id +APACHE_THRIFT_DEFINE_ACCESSOR(space_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_name +#define APACHE_THRIFT_ACCESSOR_name +APACHE_THRIFT_DEFINE_ACCESSOR(name); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_space_id +#define APACHE_THRIFT_ACCESSOR_space_id +APACHE_THRIFT_DEFINE_ACCESSOR(space_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_sign +#define APACHE_THRIFT_ACCESSOR_sign +APACHE_THRIFT_DEFINE_ACCESSOR(sign); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_result +#define APACHE_THRIFT_ACCESSOR_result +APACHE_THRIFT_DEFINE_ACCESSOR(result); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_leader_parts +#define APACHE_THRIFT_ACCESSOR_leader_parts +APACHE_THRIFT_DEFINE_ACCESSOR(leader_parts); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_space_id +#define APACHE_THRIFT_ACCESSOR_space_id +APACHE_THRIFT_DEFINE_ACCESSOR(space_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_part_id +#define APACHE_THRIFT_ACCESSOR_part_id +APACHE_THRIFT_DEFINE_ACCESSOR(part_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_peers +#define APACHE_THRIFT_ACCESSOR_peers +APACHE_THRIFT_DEFINE_ACCESSOR(peers); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_space_id +#define APACHE_THRIFT_ACCESSOR_space_id +APACHE_THRIFT_DEFINE_ACCESSOR(space_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_parts +#define APACHE_THRIFT_ACCESSOR_parts +APACHE_THRIFT_DEFINE_ACCESSOR(parts); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_index_id +#define APACHE_THRIFT_ACCESSOR_index_id +APACHE_THRIFT_DEFINE_ACCESSOR(index_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_result +#define APACHE_THRIFT_ACCESSOR_result +APACHE_THRIFT_DEFINE_ACCESSOR(result); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_info +#define APACHE_THRIFT_ACCESSOR_info +APACHE_THRIFT_DEFINE_ACCESSOR(info); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_result +#define APACHE_THRIFT_ACCESSOR_result +APACHE_THRIFT_DEFINE_ACCESSOR(result); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_dir +#define APACHE_THRIFT_ACCESSOR_dir +APACHE_THRIFT_DEFINE_ACCESSOR(dir); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_space_id +#define APACHE_THRIFT_ACCESSOR_space_id +APACHE_THRIFT_DEFINE_ACCESSOR(space_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_parts +#define APACHE_THRIFT_ACCESSOR_parts +APACHE_THRIFT_DEFINE_ACCESSOR(parts); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_return_partly +#define APACHE_THRIFT_ACCESSOR_return_partly +APACHE_THRIFT_DEFINE_ACCESSOR(return_partly); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_result +#define APACHE_THRIFT_ACCESSOR_result +APACHE_THRIFT_DEFINE_ACCESSOR(result); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_key_values +#define APACHE_THRIFT_ACCESSOR_key_values +APACHE_THRIFT_DEFINE_ACCESSOR(key_values); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_space_id +#define APACHE_THRIFT_ACCESSOR_space_id +APACHE_THRIFT_DEFINE_ACCESSOR(space_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_parts +#define APACHE_THRIFT_ACCESSOR_parts +APACHE_THRIFT_DEFINE_ACCESSOR(parts); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_space_id +#define APACHE_THRIFT_ACCESSOR_space_id +APACHE_THRIFT_DEFINE_ACCESSOR(space_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_parts +#define APACHE_THRIFT_ACCESSOR_parts +APACHE_THRIFT_DEFINE_ACCESSOR(parts); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_txn_id +#define APACHE_THRIFT_ACCESSOR_txn_id +APACHE_THRIFT_DEFINE_ACCESSOR(txn_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_term_of_parts +#define APACHE_THRIFT_ACCESSOR_term_of_parts +APACHE_THRIFT_DEFINE_ACCESSOR(term_of_parts); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_add_edge_req +#define APACHE_THRIFT_ACCESSOR_add_edge_req +APACHE_THRIFT_DEFINE_ACCESSOR(add_edge_req); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_upd_edge_req +#define APACHE_THRIFT_ACCESSOR_upd_edge_req +APACHE_THRIFT_DEFINE_ACCESSOR(upd_edge_req); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_edge_ver +#define APACHE_THRIFT_ACCESSOR_edge_ver +APACHE_THRIFT_DEFINE_ACCESSOR(edge_ver); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_space_id +#define APACHE_THRIFT_ACCESSOR_space_id +APACHE_THRIFT_DEFINE_ACCESSOR(space_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_parts +#define APACHE_THRIFT_ACCESSOR_parts +APACHE_THRIFT_DEFINE_ACCESSOR(parts); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_prop_names +#define APACHE_THRIFT_ACCESSOR_prop_names +APACHE_THRIFT_DEFINE_ACCESSOR(prop_names); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_if_not_exists +#define APACHE_THRIFT_ACCESSOR_if_not_exists +APACHE_THRIFT_DEFINE_ACCESSOR(if_not_exists); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_term +#define APACHE_THRIFT_ACCESSOR_term +APACHE_THRIFT_DEFINE_ACCESSOR(term); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_edge_version +#define APACHE_THRIFT_ACCESSOR_edge_version +APACHE_THRIFT_DEFINE_ACCESSOR(edge_version); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_update_edge_request +#define APACHE_THRIFT_ACCESSOR_update_edge_request +APACHE_THRIFT_DEFINE_ACCESSOR(update_edge_request); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_term +#define APACHE_THRIFT_ACCESSOR_term +APACHE_THRIFT_DEFINE_ACCESSOR(term); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_edge_version +#define APACHE_THRIFT_ACCESSOR_edge_version +APACHE_THRIFT_DEFINE_ACCESSOR(edge_version); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_space_id +#define APACHE_THRIFT_ACCESSOR_space_id +APACHE_THRIFT_DEFINE_ACCESSOR(space_id); +#endif +#ifndef APACHE_THRIFT_ACCESSOR_parts +#define APACHE_THRIFT_ACCESSOR_parts +APACHE_THRIFT_DEFINE_ACCESSOR(parts); +#endif +} // namespace detail +} // namespace thrift +} // namespace apache + +// BEGIN declare_enums +namespace nebula { namespace storage { namespace cpp2 { + +enum class StatType { + SUM = 1, + COUNT = 2, + AVG = 3, + MAX = 4, + MIN = 5, +}; + + + + +enum class OrderDirection { + ASCENDING = 1, + DESCENDING = 2, +}; + + + + +enum class EdgeDirection { + BOTH = 1, + IN_EDGE = 2, + OUT_EDGE = 3, +}; + + + + +enum class ScanType { + PREFIX = 1, + RANGE = 2, +}; + + + + +enum class EngineSignType { + BLOCK_ON = 1, + BLOCK_OFF = 2, +}; + + + + +}}} // nebula::storage::cpp2 +namespace std { + + +template<> struct hash : public apache::thrift::detail::enum_hash {}; +template<> struct equal_to : public apache::thrift::detail::enum_equal_to {}; + + +template<> struct hash : public apache::thrift::detail::enum_hash {}; +template<> struct equal_to : public apache::thrift::detail::enum_equal_to {}; + + +template<> struct hash : public apache::thrift::detail::enum_hash {}; +template<> struct equal_to : public apache::thrift::detail::enum_equal_to {}; + + +template<> struct hash : public apache::thrift::detail::enum_hash {}; +template<> struct equal_to : public apache::thrift::detail::enum_equal_to {}; + + +template<> struct hash : public apache::thrift::detail::enum_hash {}; +template<> struct equal_to : public apache::thrift::detail::enum_equal_to {}; + + +} // std + +namespace apache { namespace thrift { + + +template <> struct TEnumDataStorage<::nebula::storage::cpp2::StatType>; + +template <> struct TEnumTraits<::nebula::storage::cpp2::StatType> { + using type = ::nebula::storage::cpp2::StatType; + + static constexpr std::size_t const size = 5; + static folly::Range const values; + static folly::Range const names; + + static char const* findName(type value); + static bool findValue(char const* name, type* out); + + static constexpr type min() { return type::SUM; } + static constexpr type max() { return type::MIN; } +}; + + +template <> struct TEnumDataStorage<::nebula::storage::cpp2::OrderDirection>; + +template <> struct TEnumTraits<::nebula::storage::cpp2::OrderDirection> { + using type = ::nebula::storage::cpp2::OrderDirection; + + static constexpr std::size_t const size = 2; + static folly::Range const values; + static folly::Range const names; + + static char const* findName(type value); + static bool findValue(char const* name, type* out); + + static constexpr type min() { return type::ASCENDING; } + static constexpr type max() { return type::DESCENDING; } +}; + + +template <> struct TEnumDataStorage<::nebula::storage::cpp2::EdgeDirection>; + +template <> struct TEnumTraits<::nebula::storage::cpp2::EdgeDirection> { + using type = ::nebula::storage::cpp2::EdgeDirection; + + static constexpr std::size_t const size = 3; + static folly::Range const values; + static folly::Range const names; + + static char const* findName(type value); + static bool findValue(char const* name, type* out); + + static constexpr type min() { return type::BOTH; } + static constexpr type max() { return type::OUT_EDGE; } +}; + + +template <> struct TEnumDataStorage<::nebula::storage::cpp2::ScanType>; + +template <> struct TEnumTraits<::nebula::storage::cpp2::ScanType> { + using type = ::nebula::storage::cpp2::ScanType; + + static constexpr std::size_t const size = 2; + static folly::Range const values; + static folly::Range const names; + + static char const* findName(type value); + static bool findValue(char const* name, type* out); + + static constexpr type min() { return type::PREFIX; } + static constexpr type max() { return type::RANGE; } +}; + + +template <> struct TEnumDataStorage<::nebula::storage::cpp2::EngineSignType>; + +template <> struct TEnumTraits<::nebula::storage::cpp2::EngineSignType> { + using type = ::nebula::storage::cpp2::EngineSignType; + + static constexpr std::size_t const size = 2; + static folly::Range const values; + static folly::Range const names; + + static char const* findName(type value); + static bool findValue(char const* name, type* out); + + static constexpr type min() { return type::BLOCK_ON; } + static constexpr type max() { return type::BLOCK_OFF; } +}; + + +}} // apache::thrift + +namespace nebula { namespace storage { namespace cpp2 { + +using _StatType_EnumMapFactory = apache::thrift::detail::TEnumMapFactory; +[[deprecated("use apache::thrift::util::enumNameSafe, apache::thrift::util::enumName, or apache::thrift::TEnumTraits")]] +extern const _StatType_EnumMapFactory::ValuesToNamesMapType _StatType_VALUES_TO_NAMES; +[[deprecated("use apache::thrift::TEnumTraits")]] +extern const _StatType_EnumMapFactory::NamesToValuesMapType _StatType_NAMES_TO_VALUES; + +using _OrderDirection_EnumMapFactory = apache::thrift::detail::TEnumMapFactory; +[[deprecated("use apache::thrift::util::enumNameSafe, apache::thrift::util::enumName, or apache::thrift::TEnumTraits")]] +extern const _OrderDirection_EnumMapFactory::ValuesToNamesMapType _OrderDirection_VALUES_TO_NAMES; +[[deprecated("use apache::thrift::TEnumTraits")]] +extern const _OrderDirection_EnumMapFactory::NamesToValuesMapType _OrderDirection_NAMES_TO_VALUES; + +using _EdgeDirection_EnumMapFactory = apache::thrift::detail::TEnumMapFactory; +[[deprecated("use apache::thrift::util::enumNameSafe, apache::thrift::util::enumName, or apache::thrift::TEnumTraits")]] +extern const _EdgeDirection_EnumMapFactory::ValuesToNamesMapType _EdgeDirection_VALUES_TO_NAMES; +[[deprecated("use apache::thrift::TEnumTraits")]] +extern const _EdgeDirection_EnumMapFactory::NamesToValuesMapType _EdgeDirection_NAMES_TO_VALUES; + +using _ScanType_EnumMapFactory = apache::thrift::detail::TEnumMapFactory; +[[deprecated("use apache::thrift::util::enumNameSafe, apache::thrift::util::enumName, or apache::thrift::TEnumTraits")]] +extern const _ScanType_EnumMapFactory::ValuesToNamesMapType _ScanType_VALUES_TO_NAMES; +[[deprecated("use apache::thrift::TEnumTraits")]] +extern const _ScanType_EnumMapFactory::NamesToValuesMapType _ScanType_NAMES_TO_VALUES; + +using _EngineSignType_EnumMapFactory = apache::thrift::detail::TEnumMapFactory; +[[deprecated("use apache::thrift::util::enumNameSafe, apache::thrift::util::enumName, or apache::thrift::TEnumTraits")]] +extern const _EngineSignType_EnumMapFactory::ValuesToNamesMapType _EngineSignType_VALUES_TO_NAMES; +[[deprecated("use apache::thrift::TEnumTraits")]] +extern const _EngineSignType_EnumMapFactory::NamesToValuesMapType _EngineSignType_NAMES_TO_VALUES; + +}}} // nebula::storage::cpp2 + +// END declare_enums +// BEGIN forward_declare +namespace nebula { namespace storage { namespace cpp2 { +class RequestCommon; +class PartitionResult; +class ResponseCommon; +class StatProp; +class Expr; +class EdgeProp; +class VertexProp; +class OrderBy; +class TraverseSpec; +class GetNeighborsRequest; +class GetNeighborsResponse; +class ExecResponse; +class GetPropRequest; +class GetPropResponse; +class NewTag; +class NewVertex; +class EdgeKey; +class NewEdge; +class AddVerticesRequest; +class AddEdgesRequest; +class DeleteVerticesRequest; +class DeleteEdgesRequest; +class DelTags; +class DeleteTagsRequest; +class UpdateResponse; +class UpdatedProp; +class UpdateVertexRequest; +class UpdateEdgeRequest; +class GetUUIDReq; +class GetUUIDResp; +class LookupIndexResp; +class IndexColumnHint; +class IndexQueryContext; +class IndexSpec; +class LookupIndexRequest; +class LookupAndTraverseRequest; +class ScanVertexRequest; +class ScanVertexResponse; +class ScanEdgeRequest; +class ScanEdgeResponse; +class TaskPara; +class AddAdminTaskRequest; +class StopAdminTaskRequest; +class AdminExecResp; +class TransLeaderReq; +class AddPartReq; +class AddLearnerReq; +class RemovePartReq; +class MemberChangeReq; +class CatchUpDataReq; +class GetLeaderReq; +class CreateCPRequest; +class DropCPRequest; +class BlockingSignRequest; +class GetLeaderPartsResp; +class CheckPeersReq; +class RebuildIndexRequest; +class CreateCPResp; +class ListClusterInfoResp; +class ListClusterInfoReq; +class KVGetRequest; +class KVGetResponse; +class KVPutRequest; +class KVRemoveRequest; +class InternalTxnRequest; +class ChainAddEdgesRequest; +class ChainUpdateEdgeRequest; +}}} // nebula::storage::cpp2 +// END forward_declare +// BEGIN typedefs + +// END typedefs +// BEGIN hash_and_equal_to +// END hash_and_equal_to +namespace nebula { namespace storage { namespace cpp2 { +class RequestCommon final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = RequestCommon; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + RequestCommon() : + session_id(0), + plan_id(0), + profile_detail(0) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + RequestCommon(apache::thrift::FragileConstructor, ::nebula::cpp2::SessionID session_id__arg, ::nebula::cpp2::ExecutionPlanID plan_id__arg, bool profile_detail__arg); + + RequestCommon(RequestCommon&&) = default; + + RequestCommon(const RequestCommon&) = default; + + + RequestCommon& operator=(RequestCommon&&) = default; + + RequestCommon& operator=(const RequestCommon&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::SessionID session_id; + private: + ::nebula::cpp2::ExecutionPlanID plan_id; + private: + bool profile_detail; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool session_id; + bool plan_id; + bool profile_detail; + } __isset = {}; + bool operator==(const RequestCommon& rhs) const; +#ifndef SWIG + friend bool operator!=(const RequestCommon& __x, const RequestCommon& __y) { + return !(__x == __y); + } +#endif + bool operator<(const RequestCommon& rhs) const; +#ifndef SWIG + friend bool operator>(const RequestCommon& __x, const RequestCommon& __y) { + return __y < __x; + } + friend bool operator<=(const RequestCommon& __x, const RequestCommon& __y) { + return !(__y < __x); + } + friend bool operator>=(const RequestCommon& __x, const RequestCommon& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::optional_field_ref session_id_ref() const& { + return {this->session_id, __isset.session_id}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref session_id_ref() const&& { + return {std::move(this->session_id), __isset.session_id}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref session_id_ref() & { + return {this->session_id, __isset.session_id}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref session_id_ref() && { + return {std::move(this->session_id), __isset.session_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::optional_field_ref plan_id_ref() const& { + return {this->plan_id, __isset.plan_id}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref plan_id_ref() const&& { + return {std::move(this->plan_id), __isset.plan_id}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref plan_id_ref() & { + return {this->plan_id, __isset.plan_id}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref plan_id_ref() && { + return {std::move(this->plan_id), __isset.plan_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::optional_field_ref profile_detail_ref() const& { + return {this->profile_detail, __isset.profile_detail}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref profile_detail_ref() const&& { + return {std::move(this->profile_detail), __isset.profile_detail}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref profile_detail_ref() & { + return {this->profile_detail, __isset.profile_detail}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref profile_detail_ref() && { + return {std::move(this->profile_detail), __isset.profile_detail}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + const ::nebula::cpp2::SessionID* get_session_id() const& { + return session_id_ref() ? std::addressof(session_id) : nullptr; + } + + ::nebula::cpp2::SessionID* get_session_id() & { + return session_id_ref() ? std::addressof(session_id) : nullptr; + } + ::nebula::cpp2::SessionID* get_session_id() && = delete; + + ::nebula::cpp2::SessionID& set_session_id( ::nebula::cpp2::SessionID session_id_) { + session_id = session_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.session_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return session_id; + } + + const ::nebula::cpp2::ExecutionPlanID* get_plan_id() const& { + return plan_id_ref() ? std::addressof(plan_id) : nullptr; + } + + ::nebula::cpp2::ExecutionPlanID* get_plan_id() & { + return plan_id_ref() ? std::addressof(plan_id) : nullptr; + } + ::nebula::cpp2::ExecutionPlanID* get_plan_id() && = delete; + + ::nebula::cpp2::ExecutionPlanID& set_plan_id( ::nebula::cpp2::ExecutionPlanID plan_id_) { + plan_id = plan_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.plan_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return plan_id; + } + + const bool* get_profile_detail() const& { + return profile_detail_ref() ? std::addressof(profile_detail) : nullptr; + } + + bool* get_profile_detail() & { + return profile_detail_ref() ? std::addressof(profile_detail) : nullptr; + } + bool* get_profile_detail() && = delete; + + bool& set_profile_detail(bool profile_detail_) { + profile_detail = profile_detail_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.profile_detail = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return profile_detail; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< RequestCommon >; + friend void swap(RequestCommon& a, RequestCommon& b); +}; + +template +uint32_t RequestCommon::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { +class PartitionResult final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = PartitionResult; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + PartitionResult() : + code( ::nebula::cpp2::ErrorCode::SUCCEEDED), + part_id(0) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + PartitionResult(apache::thrift::FragileConstructor, ::nebula::cpp2::ErrorCode code__arg, ::nebula::cpp2::PartitionID part_id__arg, nebula::HostAddr leader__arg); + + PartitionResult(PartitionResult&&) = default; + + PartitionResult(const PartitionResult&) = default; + + + PartitionResult& operator=(PartitionResult&&) = default; + + PartitionResult& operator=(const PartitionResult&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + public: + ::nebula::cpp2::ErrorCode code; + public: + ::nebula::cpp2::PartitionID part_id; + private: + nebula::HostAddr leader; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool leader; + } __isset = {}; + bool operator==(const PartitionResult& rhs) const; +#ifndef SWIG + friend bool operator!=(const PartitionResult& __x, const PartitionResult& __y) { + return !(__x == __y); + } +#endif + bool operator<(const PartitionResult& rhs) const; +#ifndef SWIG + friend bool operator>(const PartitionResult& __x, const PartitionResult& __y) { + return __y < __x; + } + friend bool operator<=(const PartitionResult& __x, const PartitionResult& __y) { + return !(__y < __x); + } + friend bool operator>=(const PartitionResult& __x, const PartitionResult& __y) { + return !(__x < __y); + } +#endif + template + FOLLY_ERASE ::apache::thrift::required_field_ref code_ref() const& { + return ::apache::thrift::required_field_ref{this->code}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref code_ref() const&& { + return ::apache::thrift::required_field_ref{std::move(this->code)}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref code_ref() & { + return ::apache::thrift::required_field_ref{this->code}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref code_ref() && { + return ::apache::thrift::required_field_ref{std::move(this->code)}; + } + template + FOLLY_ERASE ::apache::thrift::required_field_ref part_id_ref() const& { + return ::apache::thrift::required_field_ref{this->part_id}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref part_id_ref() const&& { + return ::apache::thrift::required_field_ref{std::move(this->part_id)}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref part_id_ref() & { + return ::apache::thrift::required_field_ref{this->part_id}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref part_id_ref() && { + return ::apache::thrift::required_field_ref{std::move(this->part_id)}; + } + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::optional_field_ref leader_ref() const& { + return {this->leader, __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref leader_ref() const&& { + return {std::move(this->leader), __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref leader_ref() & { + return {this->leader, __isset.leader}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref leader_ref() && { + return {std::move(this->leader), __isset.leader}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::ErrorCode get_code() const { + return code; + } + + ::nebula::cpp2::ErrorCode& set_code( ::nebula::cpp2::ErrorCode code_) { + code = code_; + return code; + } + + ::nebula::cpp2::PartitionID get_part_id() const { + return part_id; + } + + ::nebula::cpp2::PartitionID& set_part_id( ::nebula::cpp2::PartitionID part_id_) { + part_id = part_id_; + return part_id; + } + const nebula::HostAddr* get_leader() const&; + nebula::HostAddr* get_leader() &; + nebula::HostAddr* get_leader() && = delete; + + template + nebula::HostAddr& set_leader(T_PartitionResult_leader_struct_setter&& leader_) { + leader = std::forward(leader_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.leader = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return leader; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< PartitionResult >; + friend void swap(PartitionResult& a, PartitionResult& b); +}; + +template +uint32_t PartitionResult::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { +class ResponseCommon final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = ResponseCommon; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + ResponseCommon() : + latency_in_us(0) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + ResponseCommon(apache::thrift::FragileConstructor, ::std::vector< ::nebula::storage::cpp2::PartitionResult> failed_parts__arg, int32_t latency_in_us__arg, ::std::map<::std::string, int32_t> latency_detail_us__arg); + + ResponseCommon(ResponseCommon&&) = default; + + ResponseCommon(const ResponseCommon&) = default; + + + ResponseCommon& operator=(ResponseCommon&&) = default; + + ResponseCommon& operator=(const ResponseCommon&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + public: + ::std::vector< ::nebula::storage::cpp2::PartitionResult> failed_parts; + public: + int32_t latency_in_us; + private: + ::std::map<::std::string, int32_t> latency_detail_us; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool latency_detail_us; + } __isset = {}; + bool operator==(const ResponseCommon& rhs) const; +#ifndef SWIG + friend bool operator!=(const ResponseCommon& __x, const ResponseCommon& __y) { + return !(__x == __y); + } +#endif + bool operator<(const ResponseCommon& rhs) const; +#ifndef SWIG + friend bool operator>(const ResponseCommon& __x, const ResponseCommon& __y) { + return __y < __x; + } + friend bool operator<=(const ResponseCommon& __x, const ResponseCommon& __y) { + return !(__y < __x); + } + friend bool operator>=(const ResponseCommon& __x, const ResponseCommon& __y) { + return !(__x < __y); + } +#endif + template > + FOLLY_ERASE ::apache::thrift::required_field_ref failed_parts_ref() const& { + return ::apache::thrift::required_field_ref{this->failed_parts}; + } + + template > + FOLLY_ERASE ::apache::thrift::required_field_ref failed_parts_ref() const&& { + return ::apache::thrift::required_field_ref{std::move(this->failed_parts)}; + } + + template > + FOLLY_ERASE ::apache::thrift::required_field_ref failed_parts_ref() & { + return ::apache::thrift::required_field_ref{this->failed_parts}; + } + + template > + FOLLY_ERASE ::apache::thrift::required_field_ref failed_parts_ref() && { + return ::apache::thrift::required_field_ref{std::move(this->failed_parts)}; + } + template + FOLLY_ERASE ::apache::thrift::required_field_ref latency_in_us_ref() const& { + return ::apache::thrift::required_field_ref{this->latency_in_us}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref latency_in_us_ref() const&& { + return ::apache::thrift::required_field_ref{std::move(this->latency_in_us)}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref latency_in_us_ref() & { + return ::apache::thrift::required_field_ref{this->latency_in_us}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref latency_in_us_ref() && { + return ::apache::thrift::required_field_ref{std::move(this->latency_in_us)}; + } + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::optional_field_ref latency_detail_us_ref() const& { + return {this->latency_detail_us, __isset.latency_detail_us}; + } + + template > + FOLLY_ERASE ::apache::thrift::optional_field_ref latency_detail_us_ref() const&& { + return {std::move(this->latency_detail_us), __isset.latency_detail_us}; + } + + template > + FOLLY_ERASE ::apache::thrift::optional_field_ref latency_detail_us_ref() & { + return {this->latency_detail_us, __isset.latency_detail_us}; + } + + template > + FOLLY_ERASE ::apache::thrift::optional_field_ref latency_detail_us_ref() && { + return {std::move(this->latency_detail_us), __isset.latency_detail_us}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + const ::std::vector< ::nebula::storage::cpp2::PartitionResult>& get_failed_parts() const&; + ::std::vector< ::nebula::storage::cpp2::PartitionResult> get_failed_parts() &&; + + template > + ::std::vector< ::nebula::storage::cpp2::PartitionResult>& set_failed_parts(T_ResponseCommon_failed_parts_struct_setter&& failed_parts_) { + failed_parts = std::forward(failed_parts_); + return failed_parts; + } + + int32_t get_latency_in_us() const { + return latency_in_us; + } + + int32_t& set_latency_in_us(int32_t latency_in_us_) { + latency_in_us = latency_in_us_; + return latency_in_us; + } + const ::std::map<::std::string, int32_t>* get_latency_detail_us() const&; + ::std::map<::std::string, int32_t>* get_latency_detail_us() &; + ::std::map<::std::string, int32_t>* get_latency_detail_us() && = delete; + + template > + ::std::map<::std::string, int32_t>& set_latency_detail_us(T_ResponseCommon_latency_detail_us_struct_setter&& latency_detail_us_) { + latency_detail_us = std::forward(latency_detail_us_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.latency_detail_us = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return latency_detail_us; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< ResponseCommon >; + friend void swap(ResponseCommon& a, ResponseCommon& b); +}; + +template +uint32_t ResponseCommon::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { +class StatProp final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = StatProp; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + StatProp() : + stat(static_cast< ::nebula::storage::cpp2::StatType>(0)) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + StatProp(apache::thrift::FragileConstructor, ::std::string alias__arg, ::std::string prop__arg, ::nebula::storage::cpp2::StatType stat__arg); + + StatProp(StatProp&&) = default; + + StatProp(const StatProp&) = default; + + + StatProp& operator=(StatProp&&) = default; + + StatProp& operator=(const StatProp&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::std::string alias; + private: + ::std::string prop; + private: + ::nebula::storage::cpp2::StatType stat; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool alias; + bool prop; + bool stat; + } __isset = {}; + bool operator==(const StatProp& rhs) const; +#ifndef SWIG + friend bool operator!=(const StatProp& __x, const StatProp& __y) { + return !(__x == __y); + } +#endif + bool operator<(const StatProp& rhs) const; +#ifndef SWIG + friend bool operator>(const StatProp& __x, const StatProp& __y) { + return __y < __x; + } + friend bool operator<=(const StatProp& __x, const StatProp& __y) { + return !(__y < __x); + } + friend bool operator>=(const StatProp& __x, const StatProp& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref alias_ref() const& { + return {this->alias, __isset.alias}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref alias_ref() const&& { + return {std::move(this->alias), __isset.alias}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref alias_ref() & { + return {this->alias, __isset.alias}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref alias_ref() && { + return {std::move(this->alias), __isset.alias}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref prop_ref() const& { + return {this->prop, __isset.prop}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref prop_ref() const&& { + return {std::move(this->prop), __isset.prop}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref prop_ref() & { + return {this->prop, __isset.prop}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref prop_ref() && { + return {std::move(this->prop), __isset.prop}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref stat_ref() const& { + return {this->stat, __isset.stat}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref stat_ref() const&& { + return {std::move(this->stat), __isset.stat}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref stat_ref() & { + return {this->stat, __isset.stat}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref stat_ref() && { + return {std::move(this->stat), __isset.stat}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + const ::std::string& get_alias() const& { + return alias; + } + + ::std::string get_alias() && { + return std::move(alias); + } + + template + ::std::string& set_alias(T_StatProp_alias_struct_setter&& alias_) { + alias = std::forward(alias_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.alias = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return alias; + } + + const ::std::string& get_prop() const& { + return prop; + } + + ::std::string get_prop() && { + return std::move(prop); + } + + template + ::std::string& set_prop(T_StatProp_prop_struct_setter&& prop_) { + prop = std::forward(prop_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.prop = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return prop; + } + + ::nebula::storage::cpp2::StatType get_stat() const { + return stat; + } + + ::nebula::storage::cpp2::StatType& set_stat( ::nebula::storage::cpp2::StatType stat_) { + stat = stat_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.stat = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return stat; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< StatProp >; + friend void swap(StatProp& a, StatProp& b); +}; + +template +uint32_t StatProp::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { +class Expr final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = Expr; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + Expr() {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + Expr(apache::thrift::FragileConstructor, ::std::string alias__arg, ::std::string expr__arg); + + Expr(Expr&&) = default; + + Expr(const Expr&) = default; + + + Expr& operator=(Expr&&) = default; + + Expr& operator=(const Expr&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::std::string alias; + private: + ::std::string expr; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool alias; + bool expr; + } __isset = {}; + bool operator==(const Expr& rhs) const; +#ifndef SWIG + friend bool operator!=(const Expr& __x, const Expr& __y) { + return !(__x == __y); + } +#endif + bool operator<(const Expr& rhs) const; +#ifndef SWIG + friend bool operator>(const Expr& __x, const Expr& __y) { + return __y < __x; + } + friend bool operator<=(const Expr& __x, const Expr& __y) { + return !(__y < __x); + } + friend bool operator>=(const Expr& __x, const Expr& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref alias_ref() const& { + return {this->alias, __isset.alias}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref alias_ref() const&& { + return {std::move(this->alias), __isset.alias}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref alias_ref() & { + return {this->alias, __isset.alias}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref alias_ref() && { + return {std::move(this->alias), __isset.alias}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref expr_ref() const& { + return {this->expr, __isset.expr}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref expr_ref() const&& { + return {std::move(this->expr), __isset.expr}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref expr_ref() & { + return {this->expr, __isset.expr}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref expr_ref() && { + return {std::move(this->expr), __isset.expr}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + const ::std::string& get_alias() const& { + return alias; + } + + ::std::string get_alias() && { + return std::move(alias); + } + + template + ::std::string& set_alias(T_Expr_alias_struct_setter&& alias_) { + alias = std::forward(alias_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.alias = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return alias; + } + + const ::std::string& get_expr() const& { + return expr; + } + + ::std::string get_expr() && { + return std::move(expr); + } + + template + ::std::string& set_expr(T_Expr_expr_struct_setter&& expr_) { + expr = std::forward(expr_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.expr = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return expr; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< Expr >; + friend void swap(Expr& a, Expr& b); +}; + +template +uint32_t Expr::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { +class EdgeProp final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = EdgeProp; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + EdgeProp() : + type(0) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + EdgeProp(apache::thrift::FragileConstructor, ::nebula::cpp2::EdgeType type__arg, ::std::vector<::std::string> props__arg); + + EdgeProp(EdgeProp&&) = default; + + EdgeProp(const EdgeProp&) = default; + + + EdgeProp& operator=(EdgeProp&&) = default; + + EdgeProp& operator=(const EdgeProp&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::EdgeType type; + private: + ::std::vector<::std::string> props; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool type; + bool props; + } __isset = {}; + bool operator==(const EdgeProp& rhs) const; +#ifndef SWIG + friend bool operator!=(const EdgeProp& __x, const EdgeProp& __y) { + return !(__x == __y); + } +#endif + bool operator<(const EdgeProp& rhs) const; +#ifndef SWIG + friend bool operator>(const EdgeProp& __x, const EdgeProp& __y) { + return __y < __x; + } + friend bool operator<=(const EdgeProp& __x, const EdgeProp& __y) { + return !(__y < __x); + } + friend bool operator>=(const EdgeProp& __x, const EdgeProp& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref type_ref() const& { + return {this->type, __isset.type}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref type_ref() const&& { + return {std::move(this->type), __isset.type}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref type_ref() & { + return {this->type, __isset.type}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref type_ref() && { + return {std::move(this->type), __isset.type}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::field_ref props_ref() const& { + return {this->props, __isset.props}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref props_ref() const&& { + return {std::move(this->props), __isset.props}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref props_ref() & { + return {this->props, __isset.props}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref props_ref() && { + return {std::move(this->props), __isset.props}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::EdgeType get_type() const { + return type; + } + + ::nebula::cpp2::EdgeType& set_type( ::nebula::cpp2::EdgeType type_) { + type = type_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.type = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return type; + } + const ::std::vector<::std::string>& get_props() const&; + ::std::vector<::std::string> get_props() &&; + + template > + ::std::vector<::std::string>& set_props(T_EdgeProp_props_struct_setter&& props_) { + props = std::forward(props_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.props = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return props; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< EdgeProp >; + friend void swap(EdgeProp& a, EdgeProp& b); +}; + +template +uint32_t EdgeProp::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { +class VertexProp final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = VertexProp; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + VertexProp() : + tag(0) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + VertexProp(apache::thrift::FragileConstructor, ::nebula::cpp2::TagID tag__arg, ::std::vector<::std::string> props__arg); + + VertexProp(VertexProp&&) = default; + + VertexProp(const VertexProp&) = default; + + + VertexProp& operator=(VertexProp&&) = default; + + VertexProp& operator=(const VertexProp&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::TagID tag; + private: + ::std::vector<::std::string> props; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool tag; + bool props; + } __isset = {}; + bool operator==(const VertexProp& rhs) const; +#ifndef SWIG + friend bool operator!=(const VertexProp& __x, const VertexProp& __y) { + return !(__x == __y); + } +#endif + bool operator<(const VertexProp& rhs) const; +#ifndef SWIG + friend bool operator>(const VertexProp& __x, const VertexProp& __y) { + return __y < __x; + } + friend bool operator<=(const VertexProp& __x, const VertexProp& __y) { + return !(__y < __x); + } + friend bool operator>=(const VertexProp& __x, const VertexProp& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref tag_ref() const& { + return {this->tag, __isset.tag}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref tag_ref() const&& { + return {std::move(this->tag), __isset.tag}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref tag_ref() & { + return {this->tag, __isset.tag}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref tag_ref() && { + return {std::move(this->tag), __isset.tag}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::field_ref props_ref() const& { + return {this->props, __isset.props}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref props_ref() const&& { + return {std::move(this->props), __isset.props}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref props_ref() & { + return {this->props, __isset.props}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref props_ref() && { + return {std::move(this->props), __isset.props}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::TagID get_tag() const { + return tag; + } + + ::nebula::cpp2::TagID& set_tag( ::nebula::cpp2::TagID tag_) { + tag = tag_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.tag = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return tag; + } + const ::std::vector<::std::string>& get_props() const&; + ::std::vector<::std::string> get_props() &&; + + template > + ::std::vector<::std::string>& set_props(T_VertexProp_props_struct_setter&& props_) { + props = std::forward(props_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.props = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return props; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< VertexProp >; + friend void swap(VertexProp& a, VertexProp& b); +}; + +template +uint32_t VertexProp::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { +class OrderBy final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = OrderBy; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + OrderBy() : + direction(static_cast< ::nebula::storage::cpp2::OrderDirection>(0)) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + OrderBy(apache::thrift::FragileConstructor, ::std::string prop__arg, ::nebula::storage::cpp2::OrderDirection direction__arg); + + OrderBy(OrderBy&&) = default; + + OrderBy(const OrderBy&) = default; + + + OrderBy& operator=(OrderBy&&) = default; + + OrderBy& operator=(const OrderBy&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::std::string prop; + private: + ::nebula::storage::cpp2::OrderDirection direction; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool prop; + bool direction; + } __isset = {}; + bool operator==(const OrderBy& rhs) const; +#ifndef SWIG + friend bool operator!=(const OrderBy& __x, const OrderBy& __y) { + return !(__x == __y); + } +#endif + bool operator<(const OrderBy& rhs) const; +#ifndef SWIG + friend bool operator>(const OrderBy& __x, const OrderBy& __y) { + return __y < __x; + } + friend bool operator<=(const OrderBy& __x, const OrderBy& __y) { + return !(__y < __x); + } + friend bool operator>=(const OrderBy& __x, const OrderBy& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref prop_ref() const& { + return {this->prop, __isset.prop}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref prop_ref() const&& { + return {std::move(this->prop), __isset.prop}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref prop_ref() & { + return {this->prop, __isset.prop}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref prop_ref() && { + return {std::move(this->prop), __isset.prop}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref direction_ref() const& { + return {this->direction, __isset.direction}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref direction_ref() const&& { + return {std::move(this->direction), __isset.direction}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref direction_ref() & { + return {this->direction, __isset.direction}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref direction_ref() && { + return {std::move(this->direction), __isset.direction}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + const ::std::string& get_prop() const& { + return prop; + } + + ::std::string get_prop() && { + return std::move(prop); + } + + template + ::std::string& set_prop(T_OrderBy_prop_struct_setter&& prop_) { + prop = std::forward(prop_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.prop = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return prop; + } + + ::nebula::storage::cpp2::OrderDirection get_direction() const { + return direction; + } + + ::nebula::storage::cpp2::OrderDirection& set_direction( ::nebula::storage::cpp2::OrderDirection direction_) { + direction = direction_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.direction = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return direction; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< OrderBy >; + friend void swap(OrderBy& a, OrderBy& b); +}; + +template +uint32_t OrderBy::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { +class TraverseSpec final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = TraverseSpec; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + + TraverseSpec(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + TraverseSpec(apache::thrift::FragileConstructor, ::std::vector< ::nebula::cpp2::EdgeType> edge_types__arg, ::nebula::storage::cpp2::EdgeDirection edge_direction__arg, bool dedup__arg, ::std::vector< ::nebula::storage::cpp2::StatProp> stat_props__arg, ::std::vector< ::nebula::storage::cpp2::VertexProp> vertex_props__arg, ::std::vector< ::nebula::storage::cpp2::EdgeProp> edge_props__arg, ::std::vector< ::nebula::storage::cpp2::Expr> expressions__arg, ::std::vector< ::nebula::storage::cpp2::OrderBy> order_by__arg, bool random__arg, int64_t limit__arg, ::std::string filter__arg); + + TraverseSpec(TraverseSpec&&) = default; + + TraverseSpec(const TraverseSpec&) = default; + + + TraverseSpec& operator=(TraverseSpec&&) = default; + + TraverseSpec& operator=(const TraverseSpec&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + + ~TraverseSpec(); + + private: + ::std::vector< ::nebula::cpp2::EdgeType> edge_types; + private: + ::nebula::storage::cpp2::EdgeDirection edge_direction; + private: + bool dedup; + private: + ::std::vector< ::nebula::storage::cpp2::StatProp> stat_props; + private: + ::std::vector< ::nebula::storage::cpp2::VertexProp> vertex_props; + private: + ::std::vector< ::nebula::storage::cpp2::EdgeProp> edge_props; + private: + ::std::vector< ::nebula::storage::cpp2::Expr> expressions; + private: + ::std::vector< ::nebula::storage::cpp2::OrderBy> order_by; + private: + bool random; + private: + int64_t limit; + private: + ::std::string filter; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool edge_types; + bool edge_direction; + bool dedup; + bool stat_props; + bool vertex_props; + bool edge_props; + bool expressions; + bool order_by; + bool random; + bool limit; + bool filter; + } __isset = {}; + bool operator==(const TraverseSpec& rhs) const; +#ifndef SWIG + friend bool operator!=(const TraverseSpec& __x, const TraverseSpec& __y) { + return !(__x == __y); + } +#endif + bool operator<(const TraverseSpec& rhs) const; +#ifndef SWIG + friend bool operator>(const TraverseSpec& __x, const TraverseSpec& __y) { + return __y < __x; + } + friend bool operator<=(const TraverseSpec& __x, const TraverseSpec& __y) { + return !(__y < __x); + } + friend bool operator>=(const TraverseSpec& __x, const TraverseSpec& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::field_ref edge_types_ref() const& { + return {this->edge_types, __isset.edge_types}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref edge_types_ref() const&& { + return {std::move(this->edge_types), __isset.edge_types}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref edge_types_ref() & { + return {this->edge_types, __isset.edge_types}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref edge_types_ref() && { + return {std::move(this->edge_types), __isset.edge_types}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref edge_direction_ref() const& { + return {this->edge_direction, __isset.edge_direction}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref edge_direction_ref() const&& { + return {std::move(this->edge_direction), __isset.edge_direction}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref edge_direction_ref() & { + return {this->edge_direction, __isset.edge_direction}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref edge_direction_ref() && { + return {std::move(this->edge_direction), __isset.edge_direction}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref dedup_ref() const& { + return {this->dedup, __isset.dedup}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref dedup_ref() const&& { + return {std::move(this->dedup), __isset.dedup}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref dedup_ref() & { + return {this->dedup, __isset.dedup}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref dedup_ref() && { + return {std::move(this->dedup), __isset.dedup}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::optional_field_ref stat_props_ref() const& { + return {this->stat_props, __isset.stat_props}; + } + + template > + FOLLY_ERASE ::apache::thrift::optional_field_ref stat_props_ref() const&& { + return {std::move(this->stat_props), __isset.stat_props}; + } + + template > + FOLLY_ERASE ::apache::thrift::optional_field_ref stat_props_ref() & { + return {this->stat_props, __isset.stat_props}; + } + + template > + FOLLY_ERASE ::apache::thrift::optional_field_ref stat_props_ref() && { + return {std::move(this->stat_props), __isset.stat_props}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::optional_field_ref vertex_props_ref() const& { + return {this->vertex_props, __isset.vertex_props}; + } + + template > + FOLLY_ERASE ::apache::thrift::optional_field_ref vertex_props_ref() const&& { + return {std::move(this->vertex_props), __isset.vertex_props}; + } + + template > + FOLLY_ERASE ::apache::thrift::optional_field_ref vertex_props_ref() & { + return {this->vertex_props, __isset.vertex_props}; + } + + template > + FOLLY_ERASE ::apache::thrift::optional_field_ref vertex_props_ref() && { + return {std::move(this->vertex_props), __isset.vertex_props}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::optional_field_ref edge_props_ref() const& { + return {this->edge_props, __isset.edge_props}; + } + + template > + FOLLY_ERASE ::apache::thrift::optional_field_ref edge_props_ref() const&& { + return {std::move(this->edge_props), __isset.edge_props}; + } + + template > + FOLLY_ERASE ::apache::thrift::optional_field_ref edge_props_ref() & { + return {this->edge_props, __isset.edge_props}; + } + + template > + FOLLY_ERASE ::apache::thrift::optional_field_ref edge_props_ref() && { + return {std::move(this->edge_props), __isset.edge_props}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::optional_field_ref expressions_ref() const& { + return {this->expressions, __isset.expressions}; + } + + template > + FOLLY_ERASE ::apache::thrift::optional_field_ref expressions_ref() const&& { + return {std::move(this->expressions), __isset.expressions}; + } + + template > + FOLLY_ERASE ::apache::thrift::optional_field_ref expressions_ref() & { + return {this->expressions, __isset.expressions}; + } + + template > + FOLLY_ERASE ::apache::thrift::optional_field_ref expressions_ref() && { + return {std::move(this->expressions), __isset.expressions}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::optional_field_ref order_by_ref() const& { + return {this->order_by, __isset.order_by}; + } + + template > + FOLLY_ERASE ::apache::thrift::optional_field_ref order_by_ref() const&& { + return {std::move(this->order_by), __isset.order_by}; + } + + template > + FOLLY_ERASE ::apache::thrift::optional_field_ref order_by_ref() & { + return {this->order_by, __isset.order_by}; + } + + template > + FOLLY_ERASE ::apache::thrift::optional_field_ref order_by_ref() && { + return {std::move(this->order_by), __isset.order_by}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::optional_field_ref random_ref() const& { + return {this->random, __isset.random}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref random_ref() const&& { + return {std::move(this->random), __isset.random}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref random_ref() & { + return {this->random, __isset.random}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref random_ref() && { + return {std::move(this->random), __isset.random}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::optional_field_ref limit_ref() const& { + return {this->limit, __isset.limit}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref limit_ref() const&& { + return {std::move(this->limit), __isset.limit}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref limit_ref() & { + return {this->limit, __isset.limit}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref limit_ref() && { + return {std::move(this->limit), __isset.limit}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::optional_field_ref filter_ref() const& { + return {this->filter, __isset.filter}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref filter_ref() const&& { + return {std::move(this->filter), __isset.filter}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref filter_ref() & { + return {this->filter, __isset.filter}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref filter_ref() && { + return {std::move(this->filter), __isset.filter}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + const ::std::vector< ::nebula::cpp2::EdgeType>& get_edge_types() const&; + ::std::vector< ::nebula::cpp2::EdgeType> get_edge_types() &&; + + template > + ::std::vector< ::nebula::cpp2::EdgeType>& set_edge_types(T_TraverseSpec_edge_types_struct_setter&& edge_types_) { + edge_types = std::forward(edge_types_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.edge_types = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return edge_types; + } + + ::nebula::storage::cpp2::EdgeDirection get_edge_direction() const { + return edge_direction; + } + + ::nebula::storage::cpp2::EdgeDirection& set_edge_direction( ::nebula::storage::cpp2::EdgeDirection edge_direction_) { + edge_direction = edge_direction_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.edge_direction = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return edge_direction; + } + + bool get_dedup() const { + return dedup; + } + + bool& set_dedup(bool dedup_) { + dedup = dedup_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.dedup = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return dedup; + } + const ::std::vector< ::nebula::storage::cpp2::StatProp>* get_stat_props() const&; + ::std::vector< ::nebula::storage::cpp2::StatProp>* get_stat_props() &; + ::std::vector< ::nebula::storage::cpp2::StatProp>* get_stat_props() && = delete; + + template > + ::std::vector< ::nebula::storage::cpp2::StatProp>& set_stat_props(T_TraverseSpec_stat_props_struct_setter&& stat_props_) { + stat_props = std::forward(stat_props_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.stat_props = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return stat_props; + } + const ::std::vector< ::nebula::storage::cpp2::VertexProp>* get_vertex_props() const&; + ::std::vector< ::nebula::storage::cpp2::VertexProp>* get_vertex_props() &; + ::std::vector< ::nebula::storage::cpp2::VertexProp>* get_vertex_props() && = delete; + + template > + ::std::vector< ::nebula::storage::cpp2::VertexProp>& set_vertex_props(T_TraverseSpec_vertex_props_struct_setter&& vertex_props_) { + vertex_props = std::forward(vertex_props_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.vertex_props = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return vertex_props; + } + const ::std::vector< ::nebula::storage::cpp2::EdgeProp>* get_edge_props() const&; + ::std::vector< ::nebula::storage::cpp2::EdgeProp>* get_edge_props() &; + ::std::vector< ::nebula::storage::cpp2::EdgeProp>* get_edge_props() && = delete; + + template > + ::std::vector< ::nebula::storage::cpp2::EdgeProp>& set_edge_props(T_TraverseSpec_edge_props_struct_setter&& edge_props_) { + edge_props = std::forward(edge_props_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.edge_props = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return edge_props; + } + const ::std::vector< ::nebula::storage::cpp2::Expr>* get_expressions() const&; + ::std::vector< ::nebula::storage::cpp2::Expr>* get_expressions() &; + ::std::vector< ::nebula::storage::cpp2::Expr>* get_expressions() && = delete; + + template > + ::std::vector< ::nebula::storage::cpp2::Expr>& set_expressions(T_TraverseSpec_expressions_struct_setter&& expressions_) { + expressions = std::forward(expressions_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.expressions = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return expressions; + } + const ::std::vector< ::nebula::storage::cpp2::OrderBy>* get_order_by() const&; + ::std::vector< ::nebula::storage::cpp2::OrderBy>* get_order_by() &; + ::std::vector< ::nebula::storage::cpp2::OrderBy>* get_order_by() && = delete; + + template > + ::std::vector< ::nebula::storage::cpp2::OrderBy>& set_order_by(T_TraverseSpec_order_by_struct_setter&& order_by_) { + order_by = std::forward(order_by_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.order_by = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return order_by; + } + + const bool* get_random() const& { + return random_ref() ? std::addressof(random) : nullptr; + } + + bool* get_random() & { + return random_ref() ? std::addressof(random) : nullptr; + } + bool* get_random() && = delete; + + bool& set_random(bool random_) { + random = random_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.random = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return random; + } + + const int64_t* get_limit() const& { + return limit_ref() ? std::addressof(limit) : nullptr; + } + + int64_t* get_limit() & { + return limit_ref() ? std::addressof(limit) : nullptr; + } + int64_t* get_limit() && = delete; + + int64_t& set_limit(int64_t limit_) { + limit = limit_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.limit = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return limit; + } + + const ::std::string* get_filter() const& { + return filter_ref() ? std::addressof(filter) : nullptr; + } + + ::std::string* get_filter() & { + return filter_ref() ? std::addressof(filter) : nullptr; + } + ::std::string* get_filter() && = delete; + + template + ::std::string& set_filter(T_TraverseSpec_filter_struct_setter&& filter_) { + filter = std::forward(filter_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.filter = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return filter; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< TraverseSpec >; + friend void swap(TraverseSpec& a, TraverseSpec& b); +}; + +template +uint32_t TraverseSpec::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { +class GetNeighborsRequest final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = GetNeighborsRequest; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + + GetNeighborsRequest(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + GetNeighborsRequest(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, ::std::vector<::std::string> column_names__arg, std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector> parts__arg, ::nebula::storage::cpp2::TraverseSpec traverse_spec__arg, ::nebula::storage::cpp2::RequestCommon common__arg); + + GetNeighborsRequest(GetNeighborsRequest&&) = default; + + GetNeighborsRequest(const GetNeighborsRequest&) = default; + + + GetNeighborsRequest& operator=(GetNeighborsRequest&&) = default; + + GetNeighborsRequest& operator=(const GetNeighborsRequest&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + + ~GetNeighborsRequest(); + + private: + ::nebula::cpp2::GraphSpaceID space_id; + private: + ::std::vector<::std::string> column_names; + private: + std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector> parts; + private: + ::nebula::storage::cpp2::TraverseSpec traverse_spec; + private: + ::nebula::storage::cpp2::RequestCommon common; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool space_id; + bool column_names; + bool parts; + bool traverse_spec; + bool common; + } __isset = {}; + bool operator==(const GetNeighborsRequest& rhs) const; +#ifndef SWIG + friend bool operator!=(const GetNeighborsRequest& __x, const GetNeighborsRequest& __y) { + return !(__x == __y); + } +#endif + bool operator<(const GetNeighborsRequest& rhs) const; +#ifndef SWIG + friend bool operator>(const GetNeighborsRequest& __x, const GetNeighborsRequest& __y) { + return __y < __x; + } + friend bool operator<=(const GetNeighborsRequest& __x, const GetNeighborsRequest& __y) { + return !(__y < __x); + } + friend bool operator>=(const GetNeighborsRequest& __x, const GetNeighborsRequest& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const& { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const&& { + return {std::move(this->space_id), __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() & { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() && { + return {std::move(this->space_id), __isset.space_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::field_ref column_names_ref() const& { + return {this->column_names, __isset.column_names}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref column_names_ref() const&& { + return {std::move(this->column_names), __isset.column_names}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref column_names_ref() & { + return {this->column_names, __isset.column_names}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref column_names_ref() && { + return {std::move(this->column_names), __isset.column_names}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template >> + FOLLY_ERASE ::apache::thrift::field_ref parts_ref() const& { + return {this->parts, __isset.parts}; + } + + template >> + FOLLY_ERASE ::apache::thrift::field_ref parts_ref() const&& { + return {std::move(this->parts), __isset.parts}; + } + + template >> + FOLLY_ERASE ::apache::thrift::field_ref parts_ref() & { + return {this->parts, __isset.parts}; + } + + template >> + FOLLY_ERASE ::apache::thrift::field_ref parts_ref() && { + return {std::move(this->parts), __isset.parts}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref traverse_spec_ref() const& { + return {this->traverse_spec, __isset.traverse_spec}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref traverse_spec_ref() const&& { + return {std::move(this->traverse_spec), __isset.traverse_spec}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref traverse_spec_ref() & { + return {this->traverse_spec, __isset.traverse_spec}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref traverse_spec_ref() && { + return {std::move(this->traverse_spec), __isset.traverse_spec}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::optional_field_ref common_ref() const& { + return {this->common, __isset.common}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref common_ref() const&& { + return {std::move(this->common), __isset.common}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref common_ref() & { + return {this->common, __isset.common}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref common_ref() && { + return {std::move(this->common), __isset.common}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::GraphSpaceID get_space_id() const { + return space_id; + } + + ::nebula::cpp2::GraphSpaceID& set_space_id( ::nebula::cpp2::GraphSpaceID space_id_) { + space_id = space_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.space_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return space_id; + } + const ::std::vector<::std::string>& get_column_names() const&; + ::std::vector<::std::string> get_column_names() &&; + + template > + ::std::vector<::std::string>& set_column_names(T_GetNeighborsRequest_column_names_struct_setter&& column_names_) { + column_names = std::forward(column_names_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.column_names = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return column_names; + } + const std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector>& get_parts() const&; + std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector> get_parts() &&; + + template >> + std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector>& set_parts(T_GetNeighborsRequest_parts_struct_setter&& parts_) { + parts = std::forward(parts_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.parts = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return parts; + } + const ::nebula::storage::cpp2::TraverseSpec& get_traverse_spec() const&; + ::nebula::storage::cpp2::TraverseSpec get_traverse_spec() &&; + + template + ::nebula::storage::cpp2::TraverseSpec& set_traverse_spec(T_GetNeighborsRequest_traverse_spec_struct_setter&& traverse_spec_) { + traverse_spec = std::forward(traverse_spec_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.traverse_spec = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return traverse_spec; + } + const ::nebula::storage::cpp2::RequestCommon* get_common() const&; + ::nebula::storage::cpp2::RequestCommon* get_common() &; + ::nebula::storage::cpp2::RequestCommon* get_common() && = delete; + + template + ::nebula::storage::cpp2::RequestCommon& set_common(T_GetNeighborsRequest_common_struct_setter&& common_) { + common = std::forward(common_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.common = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return common; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< GetNeighborsRequest >; + friend void swap(GetNeighborsRequest& a, GetNeighborsRequest& b); +}; + +template +uint32_t GetNeighborsRequest::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { +class GetNeighborsResponse final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = GetNeighborsResponse; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + GetNeighborsResponse() {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + GetNeighborsResponse(apache::thrift::FragileConstructor, ::nebula::storage::cpp2::ResponseCommon result__arg, nebula::DataSet vertices__arg); + + GetNeighborsResponse(GetNeighborsResponse&&) = default; + + GetNeighborsResponse(const GetNeighborsResponse&) = default; + + + GetNeighborsResponse& operator=(GetNeighborsResponse&&) = default; + + GetNeighborsResponse& operator=(const GetNeighborsResponse&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + public: + ::nebula::storage::cpp2::ResponseCommon result; + private: + nebula::DataSet vertices; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool vertices; + } __isset = {}; + bool operator==(const GetNeighborsResponse& rhs) const; +#ifndef SWIG + friend bool operator!=(const GetNeighborsResponse& __x, const GetNeighborsResponse& __y) { + return !(__x == __y); + } +#endif + bool operator<(const GetNeighborsResponse& rhs) const; +#ifndef SWIG + friend bool operator>(const GetNeighborsResponse& __x, const GetNeighborsResponse& __y) { + return __y < __x; + } + friend bool operator<=(const GetNeighborsResponse& __x, const GetNeighborsResponse& __y) { + return !(__y < __x); + } + friend bool operator>=(const GetNeighborsResponse& __x, const GetNeighborsResponse& __y) { + return !(__x < __y); + } +#endif + template + FOLLY_ERASE ::apache::thrift::required_field_ref result_ref() const& { + return ::apache::thrift::required_field_ref{this->result}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref result_ref() const&& { + return ::apache::thrift::required_field_ref{std::move(this->result)}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref result_ref() & { + return ::apache::thrift::required_field_ref{this->result}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref result_ref() && { + return ::apache::thrift::required_field_ref{std::move(this->result)}; + } + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::optional_field_ref vertices_ref() const& { + return {this->vertices, __isset.vertices}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref vertices_ref() const&& { + return {std::move(this->vertices), __isset.vertices}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref vertices_ref() & { + return {this->vertices, __isset.vertices}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref vertices_ref() && { + return {std::move(this->vertices), __isset.vertices}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + const ::nebula::storage::cpp2::ResponseCommon& get_result() const&; + ::nebula::storage::cpp2::ResponseCommon get_result() &&; + + template + ::nebula::storage::cpp2::ResponseCommon& set_result(T_GetNeighborsResponse_result_struct_setter&& result_) { + result = std::forward(result_); + return result; + } + const nebula::DataSet* get_vertices() const&; + nebula::DataSet* get_vertices() &; + nebula::DataSet* get_vertices() && = delete; + + template + nebula::DataSet& set_vertices(T_GetNeighborsResponse_vertices_struct_setter&& vertices_) { + vertices = std::forward(vertices_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.vertices = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return vertices; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< GetNeighborsResponse >; + friend void swap(GetNeighborsResponse& a, GetNeighborsResponse& b); +}; + +template +uint32_t GetNeighborsResponse::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { +class ExecResponse final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = ExecResponse; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + ExecResponse() {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + ExecResponse(apache::thrift::FragileConstructor, ::nebula::storage::cpp2::ResponseCommon result__arg); + + ExecResponse(ExecResponse&&) = default; + + ExecResponse(const ExecResponse&) = default; + + + ExecResponse& operator=(ExecResponse&&) = default; + + ExecResponse& operator=(const ExecResponse&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + public: + ::nebula::storage::cpp2::ResponseCommon result; + + public: + bool operator==(const ExecResponse& rhs) const; +#ifndef SWIG + friend bool operator!=(const ExecResponse& __x, const ExecResponse& __y) { + return !(__x == __y); + } +#endif + bool operator<(const ExecResponse& rhs) const; +#ifndef SWIG + friend bool operator>(const ExecResponse& __x, const ExecResponse& __y) { + return __y < __x; + } + friend bool operator<=(const ExecResponse& __x, const ExecResponse& __y) { + return !(__y < __x); + } + friend bool operator>=(const ExecResponse& __x, const ExecResponse& __y) { + return !(__x < __y); + } +#endif + template + FOLLY_ERASE ::apache::thrift::required_field_ref result_ref() const& { + return ::apache::thrift::required_field_ref{this->result}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref result_ref() const&& { + return ::apache::thrift::required_field_ref{std::move(this->result)}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref result_ref() & { + return ::apache::thrift::required_field_ref{this->result}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref result_ref() && { + return ::apache::thrift::required_field_ref{std::move(this->result)}; + } + const ::nebula::storage::cpp2::ResponseCommon& get_result() const&; + ::nebula::storage::cpp2::ResponseCommon get_result() &&; + + template + ::nebula::storage::cpp2::ResponseCommon& set_result(T_ExecResponse_result_struct_setter&& result_) { + result = std::forward(result_); + return result; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< ExecResponse >; + friend void swap(ExecResponse& a, ExecResponse& b); +}; + +template +uint32_t ExecResponse::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { +class GetPropRequest final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = GetPropRequest; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + + GetPropRequest(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + GetPropRequest(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector> parts__arg, ::std::vector< ::nebula::storage::cpp2::VertexProp> vertex_props__arg, ::std::vector< ::nebula::storage::cpp2::EdgeProp> edge_props__arg, ::std::vector< ::nebula::storage::cpp2::Expr> expressions__arg, bool dedup__arg, ::std::vector< ::nebula::storage::cpp2::OrderBy> order_by__arg, int64_t limit__arg, ::std::string filter__arg, ::nebula::storage::cpp2::RequestCommon common__arg); + + GetPropRequest(GetPropRequest&&) = default; + + GetPropRequest(const GetPropRequest&) = default; + + + GetPropRequest& operator=(GetPropRequest&&) = default; + + GetPropRequest& operator=(const GetPropRequest&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + + ~GetPropRequest(); + + private: + ::nebula::cpp2::GraphSpaceID space_id; + private: + std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector> parts; + private: + ::std::vector< ::nebula::storage::cpp2::VertexProp> vertex_props; + private: + ::std::vector< ::nebula::storage::cpp2::EdgeProp> edge_props; + private: + ::std::vector< ::nebula::storage::cpp2::Expr> expressions; + private: + bool dedup; + private: + ::std::vector< ::nebula::storage::cpp2::OrderBy> order_by; + private: + int64_t limit; + private: + ::std::string filter; + private: + ::nebula::storage::cpp2::RequestCommon common; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool space_id; + bool parts; + bool vertex_props; + bool edge_props; + bool expressions; + bool dedup; + bool order_by; + bool limit; + bool filter; + bool common; + } __isset = {}; + bool operator==(const GetPropRequest& rhs) const; +#ifndef SWIG + friend bool operator!=(const GetPropRequest& __x, const GetPropRequest& __y) { + return !(__x == __y); + } +#endif + bool operator<(const GetPropRequest& rhs) const; +#ifndef SWIG + friend bool operator>(const GetPropRequest& __x, const GetPropRequest& __y) { + return __y < __x; + } + friend bool operator<=(const GetPropRequest& __x, const GetPropRequest& __y) { + return !(__y < __x); + } + friend bool operator>=(const GetPropRequest& __x, const GetPropRequest& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const& { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const&& { + return {std::move(this->space_id), __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() & { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() && { + return {std::move(this->space_id), __isset.space_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template >> + FOLLY_ERASE ::apache::thrift::field_ref parts_ref() const& { + return {this->parts, __isset.parts}; + } + + template >> + FOLLY_ERASE ::apache::thrift::field_ref parts_ref() const&& { + return {std::move(this->parts), __isset.parts}; + } + + template >> + FOLLY_ERASE ::apache::thrift::field_ref parts_ref() & { + return {this->parts, __isset.parts}; + } + + template >> + FOLLY_ERASE ::apache::thrift::field_ref parts_ref() && { + return {std::move(this->parts), __isset.parts}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::optional_field_ref vertex_props_ref() const& { + return {this->vertex_props, __isset.vertex_props}; + } + + template > + FOLLY_ERASE ::apache::thrift::optional_field_ref vertex_props_ref() const&& { + return {std::move(this->vertex_props), __isset.vertex_props}; + } + + template > + FOLLY_ERASE ::apache::thrift::optional_field_ref vertex_props_ref() & { + return {this->vertex_props, __isset.vertex_props}; + } + + template > + FOLLY_ERASE ::apache::thrift::optional_field_ref vertex_props_ref() && { + return {std::move(this->vertex_props), __isset.vertex_props}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::optional_field_ref edge_props_ref() const& { + return {this->edge_props, __isset.edge_props}; + } + + template > + FOLLY_ERASE ::apache::thrift::optional_field_ref edge_props_ref() const&& { + return {std::move(this->edge_props), __isset.edge_props}; + } + + template > + FOLLY_ERASE ::apache::thrift::optional_field_ref edge_props_ref() & { + return {this->edge_props, __isset.edge_props}; + } + + template > + FOLLY_ERASE ::apache::thrift::optional_field_ref edge_props_ref() && { + return {std::move(this->edge_props), __isset.edge_props}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::optional_field_ref expressions_ref() const& { + return {this->expressions, __isset.expressions}; + } + + template > + FOLLY_ERASE ::apache::thrift::optional_field_ref expressions_ref() const&& { + return {std::move(this->expressions), __isset.expressions}; + } + + template > + FOLLY_ERASE ::apache::thrift::optional_field_ref expressions_ref() & { + return {this->expressions, __isset.expressions}; + } + + template > + FOLLY_ERASE ::apache::thrift::optional_field_ref expressions_ref() && { + return {std::move(this->expressions), __isset.expressions}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref dedup_ref() const& { + return {this->dedup, __isset.dedup}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref dedup_ref() const&& { + return {std::move(this->dedup), __isset.dedup}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref dedup_ref() & { + return {this->dedup, __isset.dedup}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref dedup_ref() && { + return {std::move(this->dedup), __isset.dedup}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::optional_field_ref order_by_ref() const& { + return {this->order_by, __isset.order_by}; + } + + template > + FOLLY_ERASE ::apache::thrift::optional_field_ref order_by_ref() const&& { + return {std::move(this->order_by), __isset.order_by}; + } + + template > + FOLLY_ERASE ::apache::thrift::optional_field_ref order_by_ref() & { + return {this->order_by, __isset.order_by}; + } + + template > + FOLLY_ERASE ::apache::thrift::optional_field_ref order_by_ref() && { + return {std::move(this->order_by), __isset.order_by}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::optional_field_ref limit_ref() const& { + return {this->limit, __isset.limit}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref limit_ref() const&& { + return {std::move(this->limit), __isset.limit}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref limit_ref() & { + return {this->limit, __isset.limit}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref limit_ref() && { + return {std::move(this->limit), __isset.limit}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::optional_field_ref filter_ref() const& { + return {this->filter, __isset.filter}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref filter_ref() const&& { + return {std::move(this->filter), __isset.filter}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref filter_ref() & { + return {this->filter, __isset.filter}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref filter_ref() && { + return {std::move(this->filter), __isset.filter}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::optional_field_ref common_ref() const& { + return {this->common, __isset.common}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref common_ref() const&& { + return {std::move(this->common), __isset.common}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref common_ref() & { + return {this->common, __isset.common}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref common_ref() && { + return {std::move(this->common), __isset.common}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::GraphSpaceID get_space_id() const { + return space_id; + } + + ::nebula::cpp2::GraphSpaceID& set_space_id( ::nebula::cpp2::GraphSpaceID space_id_) { + space_id = space_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.space_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return space_id; + } + const std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector>& get_parts() const&; + std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector> get_parts() &&; + + template >> + std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector>& set_parts(T_GetPropRequest_parts_struct_setter&& parts_) { + parts = std::forward(parts_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.parts = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return parts; + } + const ::std::vector< ::nebula::storage::cpp2::VertexProp>* get_vertex_props() const&; + ::std::vector< ::nebula::storage::cpp2::VertexProp>* get_vertex_props() &; + ::std::vector< ::nebula::storage::cpp2::VertexProp>* get_vertex_props() && = delete; + + template > + ::std::vector< ::nebula::storage::cpp2::VertexProp>& set_vertex_props(T_GetPropRequest_vertex_props_struct_setter&& vertex_props_) { + vertex_props = std::forward(vertex_props_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.vertex_props = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return vertex_props; + } + const ::std::vector< ::nebula::storage::cpp2::EdgeProp>* get_edge_props() const&; + ::std::vector< ::nebula::storage::cpp2::EdgeProp>* get_edge_props() &; + ::std::vector< ::nebula::storage::cpp2::EdgeProp>* get_edge_props() && = delete; + + template > + ::std::vector< ::nebula::storage::cpp2::EdgeProp>& set_edge_props(T_GetPropRequest_edge_props_struct_setter&& edge_props_) { + edge_props = std::forward(edge_props_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.edge_props = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return edge_props; + } + const ::std::vector< ::nebula::storage::cpp2::Expr>* get_expressions() const&; + ::std::vector< ::nebula::storage::cpp2::Expr>* get_expressions() &; + ::std::vector< ::nebula::storage::cpp2::Expr>* get_expressions() && = delete; + + template > + ::std::vector< ::nebula::storage::cpp2::Expr>& set_expressions(T_GetPropRequest_expressions_struct_setter&& expressions_) { + expressions = std::forward(expressions_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.expressions = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return expressions; + } + + bool get_dedup() const { + return dedup; + } + + bool& set_dedup(bool dedup_) { + dedup = dedup_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.dedup = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return dedup; + } + const ::std::vector< ::nebula::storage::cpp2::OrderBy>* get_order_by() const&; + ::std::vector< ::nebula::storage::cpp2::OrderBy>* get_order_by() &; + ::std::vector< ::nebula::storage::cpp2::OrderBy>* get_order_by() && = delete; + + template > + ::std::vector< ::nebula::storage::cpp2::OrderBy>& set_order_by(T_GetPropRequest_order_by_struct_setter&& order_by_) { + order_by = std::forward(order_by_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.order_by = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return order_by; + } + + const int64_t* get_limit() const& { + return limit_ref() ? std::addressof(limit) : nullptr; + } + + int64_t* get_limit() & { + return limit_ref() ? std::addressof(limit) : nullptr; + } + int64_t* get_limit() && = delete; + + int64_t& set_limit(int64_t limit_) { + limit = limit_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.limit = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return limit; + } + + const ::std::string* get_filter() const& { + return filter_ref() ? std::addressof(filter) : nullptr; + } + + ::std::string* get_filter() & { + return filter_ref() ? std::addressof(filter) : nullptr; + } + ::std::string* get_filter() && = delete; + + template + ::std::string& set_filter(T_GetPropRequest_filter_struct_setter&& filter_) { + filter = std::forward(filter_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.filter = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return filter; + } + const ::nebula::storage::cpp2::RequestCommon* get_common() const&; + ::nebula::storage::cpp2::RequestCommon* get_common() &; + ::nebula::storage::cpp2::RequestCommon* get_common() && = delete; + + template + ::nebula::storage::cpp2::RequestCommon& set_common(T_GetPropRequest_common_struct_setter&& common_) { + common = std::forward(common_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.common = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return common; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< GetPropRequest >; + friend void swap(GetPropRequest& a, GetPropRequest& b); +}; + +template +uint32_t GetPropRequest::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { +class GetPropResponse final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = GetPropResponse; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + GetPropResponse() {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + GetPropResponse(apache::thrift::FragileConstructor, ::nebula::storage::cpp2::ResponseCommon result__arg, nebula::DataSet props__arg); + + GetPropResponse(GetPropResponse&&) = default; + + GetPropResponse(const GetPropResponse&) = default; + + + GetPropResponse& operator=(GetPropResponse&&) = default; + + GetPropResponse& operator=(const GetPropResponse&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::storage::cpp2::ResponseCommon result; + private: + nebula::DataSet props; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool result; + bool props; + } __isset = {}; + bool operator==(const GetPropResponse& rhs) const; +#ifndef SWIG + friend bool operator!=(const GetPropResponse& __x, const GetPropResponse& __y) { + return !(__x == __y); + } +#endif + bool operator<(const GetPropResponse& rhs) const; +#ifndef SWIG + friend bool operator>(const GetPropResponse& __x, const GetPropResponse& __y) { + return __y < __x; + } + friend bool operator<=(const GetPropResponse& __x, const GetPropResponse& __y) { + return !(__y < __x); + } + friend bool operator>=(const GetPropResponse& __x, const GetPropResponse& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref result_ref() const& { + return {this->result, __isset.result}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref result_ref() const&& { + return {std::move(this->result), __isset.result}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref result_ref() & { + return {this->result, __isset.result}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref result_ref() && { + return {std::move(this->result), __isset.result}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::optional_field_ref props_ref() const& { + return {this->props, __isset.props}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref props_ref() const&& { + return {std::move(this->props), __isset.props}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref props_ref() & { + return {this->props, __isset.props}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref props_ref() && { + return {std::move(this->props), __isset.props}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + const ::nebula::storage::cpp2::ResponseCommon& get_result() const&; + ::nebula::storage::cpp2::ResponseCommon get_result() &&; + + template + ::nebula::storage::cpp2::ResponseCommon& set_result(T_GetPropResponse_result_struct_setter&& result_) { + result = std::forward(result_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.result = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return result; + } + const nebula::DataSet* get_props() const&; + nebula::DataSet* get_props() &; + nebula::DataSet* get_props() && = delete; + + template + nebula::DataSet& set_props(T_GetPropResponse_props_struct_setter&& props_) { + props = std::forward(props_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.props = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return props; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< GetPropResponse >; + friend void swap(GetPropResponse& a, GetPropResponse& b); +}; + +template +uint32_t GetPropResponse::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { +class NewTag final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = NewTag; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + NewTag() : + tag_id(0) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + NewTag(apache::thrift::FragileConstructor, ::nebula::cpp2::TagID tag_id__arg, ::std::vector props__arg); + + NewTag(NewTag&&) = default; + + NewTag(const NewTag&) = default; + + + NewTag& operator=(NewTag&&) = default; + + NewTag& operator=(const NewTag&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::TagID tag_id; + private: + ::std::vector props; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool tag_id; + bool props; + } __isset = {}; + bool operator==(const NewTag& rhs) const; +#ifndef SWIG + friend bool operator!=(const NewTag& __x, const NewTag& __y) { + return !(__x == __y); + } +#endif + bool operator<(const NewTag& rhs) const; +#ifndef SWIG + friend bool operator>(const NewTag& __x, const NewTag& __y) { + return __y < __x; + } + friend bool operator<=(const NewTag& __x, const NewTag& __y) { + return !(__y < __x); + } + friend bool operator>=(const NewTag& __x, const NewTag& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref tag_id_ref() const& { + return {this->tag_id, __isset.tag_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref tag_id_ref() const&& { + return {std::move(this->tag_id), __isset.tag_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref tag_id_ref() & { + return {this->tag_id, __isset.tag_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref tag_id_ref() && { + return {std::move(this->tag_id), __isset.tag_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::field_ref props_ref() const& { + return {this->props, __isset.props}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref props_ref() const&& { + return {std::move(this->props), __isset.props}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref props_ref() & { + return {this->props, __isset.props}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref props_ref() && { + return {std::move(this->props), __isset.props}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::TagID get_tag_id() const { + return tag_id; + } + + ::nebula::cpp2::TagID& set_tag_id( ::nebula::cpp2::TagID tag_id_) { + tag_id = tag_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.tag_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return tag_id; + } + const ::std::vector& get_props() const&; + ::std::vector get_props() &&; + + template > + ::std::vector& set_props(T_NewTag_props_struct_setter&& props_) { + props = std::forward(props_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.props = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return props; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< NewTag >; + friend void swap(NewTag& a, NewTag& b); +}; + +template +uint32_t NewTag::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { +class NewVertex final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = NewVertex; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + NewVertex() {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + NewVertex(apache::thrift::FragileConstructor, nebula::Value id__arg, ::std::vector< ::nebula::storage::cpp2::NewTag> tags__arg); + + NewVertex(NewVertex&&) = default; + + NewVertex(const NewVertex&) = default; + + + NewVertex& operator=(NewVertex&&) = default; + + NewVertex& operator=(const NewVertex&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + nebula::Value id; + private: + ::std::vector< ::nebula::storage::cpp2::NewTag> tags; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool id; + bool tags; + } __isset = {}; + bool operator==(const NewVertex& rhs) const; +#ifndef SWIG + friend bool operator!=(const NewVertex& __x, const NewVertex& __y) { + return !(__x == __y); + } +#endif + bool operator<(const NewVertex& rhs) const; +#ifndef SWIG + friend bool operator>(const NewVertex& __x, const NewVertex& __y) { + return __y < __x; + } + friend bool operator<=(const NewVertex& __x, const NewVertex& __y) { + return !(__y < __x); + } + friend bool operator>=(const NewVertex& __x, const NewVertex& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref id_ref() const& { + return {this->id, __isset.id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref id_ref() const&& { + return {std::move(this->id), __isset.id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref id_ref() & { + return {this->id, __isset.id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref id_ref() && { + return {std::move(this->id), __isset.id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::field_ref tags_ref() const& { + return {this->tags, __isset.tags}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref tags_ref() const&& { + return {std::move(this->tags), __isset.tags}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref tags_ref() & { + return {this->tags, __isset.tags}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref tags_ref() && { + return {std::move(this->tags), __isset.tags}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + const nebula::Value& get_id() const&; + nebula::Value get_id() &&; + + template + nebula::Value& set_id(T_NewVertex_id_struct_setter&& id_) { + id = std::forward(id_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return id; + } + const ::std::vector< ::nebula::storage::cpp2::NewTag>& get_tags() const&; + ::std::vector< ::nebula::storage::cpp2::NewTag> get_tags() &&; + + template > + ::std::vector< ::nebula::storage::cpp2::NewTag>& set_tags(T_NewVertex_tags_struct_setter&& tags_) { + tags = std::forward(tags_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.tags = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return tags; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< NewVertex >; + friend void swap(NewVertex& a, NewVertex& b); +}; + +template +uint32_t NewVertex::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { +class EdgeKey final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = EdgeKey; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + EdgeKey() : + edge_type(0), + ranking(0) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + EdgeKey(apache::thrift::FragileConstructor, nebula::Value src__arg, ::nebula::cpp2::EdgeType edge_type__arg, ::nebula::cpp2::EdgeRanking ranking__arg, nebula::Value dst__arg); + + EdgeKey(EdgeKey&&) = default; + + EdgeKey(const EdgeKey&) = default; + + + EdgeKey& operator=(EdgeKey&&) = default; + + EdgeKey& operator=(const EdgeKey&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + nebula::Value src; + private: + ::nebula::cpp2::EdgeType edge_type; + private: + ::nebula::cpp2::EdgeRanking ranking; + private: + nebula::Value dst; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool src; + bool edge_type; + bool ranking; + bool dst; + } __isset = {}; + bool operator==(const EdgeKey& rhs) const; +#ifndef SWIG + friend bool operator!=(const EdgeKey& __x, const EdgeKey& __y) { + return !(__x == __y); + } +#endif + bool operator<(const EdgeKey& rhs) const; +#ifndef SWIG + friend bool operator>(const EdgeKey& __x, const EdgeKey& __y) { + return __y < __x; + } + friend bool operator<=(const EdgeKey& __x, const EdgeKey& __y) { + return !(__y < __x); + } + friend bool operator>=(const EdgeKey& __x, const EdgeKey& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref src_ref() const& { + return {this->src, __isset.src}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref src_ref() const&& { + return {std::move(this->src), __isset.src}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref src_ref() & { + return {this->src, __isset.src}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref src_ref() && { + return {std::move(this->src), __isset.src}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref edge_type_ref() const& { + return {this->edge_type, __isset.edge_type}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref edge_type_ref() const&& { + return {std::move(this->edge_type), __isset.edge_type}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref edge_type_ref() & { + return {this->edge_type, __isset.edge_type}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref edge_type_ref() && { + return {std::move(this->edge_type), __isset.edge_type}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref ranking_ref() const& { + return {this->ranking, __isset.ranking}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref ranking_ref() const&& { + return {std::move(this->ranking), __isset.ranking}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref ranking_ref() & { + return {this->ranking, __isset.ranking}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref ranking_ref() && { + return {std::move(this->ranking), __isset.ranking}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref dst_ref() const& { + return {this->dst, __isset.dst}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref dst_ref() const&& { + return {std::move(this->dst), __isset.dst}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref dst_ref() & { + return {this->dst, __isset.dst}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref dst_ref() && { + return {std::move(this->dst), __isset.dst}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + const nebula::Value& get_src() const&; + nebula::Value get_src() &&; + + template + nebula::Value& set_src(T_EdgeKey_src_struct_setter&& src_) { + src = std::forward(src_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.src = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return src; + } + + ::nebula::cpp2::EdgeType get_edge_type() const { + return edge_type; + } + + ::nebula::cpp2::EdgeType& set_edge_type( ::nebula::cpp2::EdgeType edge_type_) { + edge_type = edge_type_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.edge_type = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return edge_type; + } + + ::nebula::cpp2::EdgeRanking get_ranking() const { + return ranking; + } + + ::nebula::cpp2::EdgeRanking& set_ranking( ::nebula::cpp2::EdgeRanking ranking_) { + ranking = ranking_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.ranking = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return ranking; + } + const nebula::Value& get_dst() const&; + nebula::Value get_dst() &&; + + template + nebula::Value& set_dst(T_EdgeKey_dst_struct_setter&& dst_) { + dst = std::forward(dst_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.dst = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return dst; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< EdgeKey >; + friend void swap(EdgeKey& a, EdgeKey& b); +}; + +template +uint32_t EdgeKey::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { +class NewEdge final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = NewEdge; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + NewEdge() {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + NewEdge(apache::thrift::FragileConstructor, ::nebula::storage::cpp2::EdgeKey key__arg, ::std::vector props__arg); + + NewEdge(NewEdge&&) = default; + + NewEdge(const NewEdge&) = default; + + + NewEdge& operator=(NewEdge&&) = default; + + NewEdge& operator=(const NewEdge&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::storage::cpp2::EdgeKey key; + private: + ::std::vector props; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool key; + bool props; + } __isset = {}; + bool operator==(const NewEdge& rhs) const; +#ifndef SWIG + friend bool operator!=(const NewEdge& __x, const NewEdge& __y) { + return !(__x == __y); + } +#endif + bool operator<(const NewEdge& rhs) const; +#ifndef SWIG + friend bool operator>(const NewEdge& __x, const NewEdge& __y) { + return __y < __x; + } + friend bool operator<=(const NewEdge& __x, const NewEdge& __y) { + return !(__y < __x); + } + friend bool operator>=(const NewEdge& __x, const NewEdge& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref key_ref() const& { + return {this->key, __isset.key}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref key_ref() const&& { + return {std::move(this->key), __isset.key}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref key_ref() & { + return {this->key, __isset.key}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref key_ref() && { + return {std::move(this->key), __isset.key}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::field_ref props_ref() const& { + return {this->props, __isset.props}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref props_ref() const&& { + return {std::move(this->props), __isset.props}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref props_ref() & { + return {this->props, __isset.props}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref props_ref() && { + return {std::move(this->props), __isset.props}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + const ::nebula::storage::cpp2::EdgeKey& get_key() const&; + ::nebula::storage::cpp2::EdgeKey get_key() &&; + + template + ::nebula::storage::cpp2::EdgeKey& set_key(T_NewEdge_key_struct_setter&& key_) { + key = std::forward(key_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.key = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return key; + } + const ::std::vector& get_props() const&; + ::std::vector get_props() &&; + + template > + ::std::vector& set_props(T_NewEdge_props_struct_setter&& props_) { + props = std::forward(props_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.props = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return props; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< NewEdge >; + friend void swap(NewEdge& a, NewEdge& b); +}; + +template +uint32_t NewEdge::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { +class AddVerticesRequest final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = AddVerticesRequest; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + + AddVerticesRequest(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + AddVerticesRequest(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::storage::cpp2::NewVertex>> parts__arg, std::unordered_map< ::nebula::cpp2::TagID, ::std::vector<::std::string>> prop_names__arg, bool if_not_exists__arg, ::nebula::storage::cpp2::RequestCommon common__arg); + + AddVerticesRequest(AddVerticesRequest&&) = default; + + AddVerticesRequest(const AddVerticesRequest&) = default; + + + AddVerticesRequest& operator=(AddVerticesRequest&&) = default; + + AddVerticesRequest& operator=(const AddVerticesRequest&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + + ~AddVerticesRequest(); + + private: + ::nebula::cpp2::GraphSpaceID space_id; + private: + std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::storage::cpp2::NewVertex>> parts; + private: + std::unordered_map< ::nebula::cpp2::TagID, ::std::vector<::std::string>> prop_names; + private: + bool if_not_exists; + private: + ::nebula::storage::cpp2::RequestCommon common; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool space_id; + bool parts; + bool prop_names; + bool if_not_exists; + bool common; + } __isset = {}; + bool operator==(const AddVerticesRequest& rhs) const; +#ifndef SWIG + friend bool operator!=(const AddVerticesRequest& __x, const AddVerticesRequest& __y) { + return !(__x == __y); + } +#endif + bool operator<(const AddVerticesRequest& rhs) const; +#ifndef SWIG + friend bool operator>(const AddVerticesRequest& __x, const AddVerticesRequest& __y) { + return __y < __x; + } + friend bool operator<=(const AddVerticesRequest& __x, const AddVerticesRequest& __y) { + return !(__y < __x); + } + friend bool operator>=(const AddVerticesRequest& __x, const AddVerticesRequest& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const& { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const&& { + return {std::move(this->space_id), __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() & { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() && { + return {std::move(this->space_id), __isset.space_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template >> + FOLLY_ERASE ::apache::thrift::field_ref parts_ref() const& { + return {this->parts, __isset.parts}; + } + + template >> + FOLLY_ERASE ::apache::thrift::field_ref parts_ref() const&& { + return {std::move(this->parts), __isset.parts}; + } + + template >> + FOLLY_ERASE ::apache::thrift::field_ref parts_ref() & { + return {this->parts, __isset.parts}; + } + + template >> + FOLLY_ERASE ::apache::thrift::field_ref parts_ref() && { + return {std::move(this->parts), __isset.parts}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template >> + FOLLY_ERASE ::apache::thrift::field_ref prop_names_ref() const& { + return {this->prop_names, __isset.prop_names}; + } + + template >> + FOLLY_ERASE ::apache::thrift::field_ref prop_names_ref() const&& { + return {std::move(this->prop_names), __isset.prop_names}; + } + + template >> + FOLLY_ERASE ::apache::thrift::field_ref prop_names_ref() & { + return {this->prop_names, __isset.prop_names}; + } + + template >> + FOLLY_ERASE ::apache::thrift::field_ref prop_names_ref() && { + return {std::move(this->prop_names), __isset.prop_names}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref if_not_exists_ref() const& { + return {this->if_not_exists, __isset.if_not_exists}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref if_not_exists_ref() const&& { + return {std::move(this->if_not_exists), __isset.if_not_exists}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref if_not_exists_ref() & { + return {this->if_not_exists, __isset.if_not_exists}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref if_not_exists_ref() && { + return {std::move(this->if_not_exists), __isset.if_not_exists}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::optional_field_ref common_ref() const& { + return {this->common, __isset.common}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref common_ref() const&& { + return {std::move(this->common), __isset.common}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref common_ref() & { + return {this->common, __isset.common}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref common_ref() && { + return {std::move(this->common), __isset.common}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::GraphSpaceID get_space_id() const { + return space_id; + } + + ::nebula::cpp2::GraphSpaceID& set_space_id( ::nebula::cpp2::GraphSpaceID space_id_) { + space_id = space_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.space_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return space_id; + } + const std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::storage::cpp2::NewVertex>>& get_parts() const&; + std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::storage::cpp2::NewVertex>> get_parts() &&; + + template >> + std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::storage::cpp2::NewVertex>>& set_parts(T_AddVerticesRequest_parts_struct_setter&& parts_) { + parts = std::forward(parts_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.parts = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return parts; + } + const std::unordered_map< ::nebula::cpp2::TagID, ::std::vector<::std::string>>& get_prop_names() const&; + std::unordered_map< ::nebula::cpp2::TagID, ::std::vector<::std::string>> get_prop_names() &&; + + template >> + std::unordered_map< ::nebula::cpp2::TagID, ::std::vector<::std::string>>& set_prop_names(T_AddVerticesRequest_prop_names_struct_setter&& prop_names_) { + prop_names = std::forward(prop_names_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.prop_names = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return prop_names; + } + + bool get_if_not_exists() const { + return if_not_exists; + } + + bool& set_if_not_exists(bool if_not_exists_) { + if_not_exists = if_not_exists_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.if_not_exists = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return if_not_exists; + } + const ::nebula::storage::cpp2::RequestCommon* get_common() const&; + ::nebula::storage::cpp2::RequestCommon* get_common() &; + ::nebula::storage::cpp2::RequestCommon* get_common() && = delete; + + template + ::nebula::storage::cpp2::RequestCommon& set_common(T_AddVerticesRequest_common_struct_setter&& common_) { + common = std::forward(common_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.common = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return common; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< AddVerticesRequest >; + friend void swap(AddVerticesRequest& a, AddVerticesRequest& b); +}; + +template +uint32_t AddVerticesRequest::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { +class AddEdgesRequest final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = AddEdgesRequest; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + + AddEdgesRequest(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + AddEdgesRequest(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::storage::cpp2::NewEdge>> parts__arg, ::std::vector<::std::string> prop_names__arg, bool if_not_exists__arg, ::nebula::storage::cpp2::RequestCommon common__arg); + + AddEdgesRequest(AddEdgesRequest&&) = default; + + AddEdgesRequest(const AddEdgesRequest&) = default; + + + AddEdgesRequest& operator=(AddEdgesRequest&&) = default; + + AddEdgesRequest& operator=(const AddEdgesRequest&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + + ~AddEdgesRequest(); + + private: + ::nebula::cpp2::GraphSpaceID space_id; + private: + std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::storage::cpp2::NewEdge>> parts; + private: + ::std::vector<::std::string> prop_names; + private: + bool if_not_exists; + private: + ::nebula::storage::cpp2::RequestCommon common; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool space_id; + bool parts; + bool prop_names; + bool if_not_exists; + bool common; + } __isset = {}; + bool operator==(const AddEdgesRequest& rhs) const; +#ifndef SWIG + friend bool operator!=(const AddEdgesRequest& __x, const AddEdgesRequest& __y) { + return !(__x == __y); + } +#endif + bool operator<(const AddEdgesRequest& rhs) const; +#ifndef SWIG + friend bool operator>(const AddEdgesRequest& __x, const AddEdgesRequest& __y) { + return __y < __x; + } + friend bool operator<=(const AddEdgesRequest& __x, const AddEdgesRequest& __y) { + return !(__y < __x); + } + friend bool operator>=(const AddEdgesRequest& __x, const AddEdgesRequest& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const& { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const&& { + return {std::move(this->space_id), __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() & { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() && { + return {std::move(this->space_id), __isset.space_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template >> + FOLLY_ERASE ::apache::thrift::field_ref parts_ref() const& { + return {this->parts, __isset.parts}; + } + + template >> + FOLLY_ERASE ::apache::thrift::field_ref parts_ref() const&& { + return {std::move(this->parts), __isset.parts}; + } + + template >> + FOLLY_ERASE ::apache::thrift::field_ref parts_ref() & { + return {this->parts, __isset.parts}; + } + + template >> + FOLLY_ERASE ::apache::thrift::field_ref parts_ref() && { + return {std::move(this->parts), __isset.parts}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::field_ref prop_names_ref() const& { + return {this->prop_names, __isset.prop_names}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref prop_names_ref() const&& { + return {std::move(this->prop_names), __isset.prop_names}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref prop_names_ref() & { + return {this->prop_names, __isset.prop_names}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref prop_names_ref() && { + return {std::move(this->prop_names), __isset.prop_names}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref if_not_exists_ref() const& { + return {this->if_not_exists, __isset.if_not_exists}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref if_not_exists_ref() const&& { + return {std::move(this->if_not_exists), __isset.if_not_exists}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref if_not_exists_ref() & { + return {this->if_not_exists, __isset.if_not_exists}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref if_not_exists_ref() && { + return {std::move(this->if_not_exists), __isset.if_not_exists}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::optional_field_ref common_ref() const& { + return {this->common, __isset.common}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref common_ref() const&& { + return {std::move(this->common), __isset.common}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref common_ref() & { + return {this->common, __isset.common}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref common_ref() && { + return {std::move(this->common), __isset.common}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::GraphSpaceID get_space_id() const { + return space_id; + } + + ::nebula::cpp2::GraphSpaceID& set_space_id( ::nebula::cpp2::GraphSpaceID space_id_) { + space_id = space_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.space_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return space_id; + } + const std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::storage::cpp2::NewEdge>>& get_parts() const&; + std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::storage::cpp2::NewEdge>> get_parts() &&; + + template >> + std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::storage::cpp2::NewEdge>>& set_parts(T_AddEdgesRequest_parts_struct_setter&& parts_) { + parts = std::forward(parts_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.parts = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return parts; + } + const ::std::vector<::std::string>& get_prop_names() const&; + ::std::vector<::std::string> get_prop_names() &&; + + template > + ::std::vector<::std::string>& set_prop_names(T_AddEdgesRequest_prop_names_struct_setter&& prop_names_) { + prop_names = std::forward(prop_names_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.prop_names = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return prop_names; + } + + bool get_if_not_exists() const { + return if_not_exists; + } + + bool& set_if_not_exists(bool if_not_exists_) { + if_not_exists = if_not_exists_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.if_not_exists = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return if_not_exists; + } + const ::nebula::storage::cpp2::RequestCommon* get_common() const&; + ::nebula::storage::cpp2::RequestCommon* get_common() &; + ::nebula::storage::cpp2::RequestCommon* get_common() && = delete; + + template + ::nebula::storage::cpp2::RequestCommon& set_common(T_AddEdgesRequest_common_struct_setter&& common_) { + common = std::forward(common_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.common = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return common; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< AddEdgesRequest >; + friend void swap(AddEdgesRequest& a, AddEdgesRequest& b); +}; + +template +uint32_t AddEdgesRequest::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { +class DeleteVerticesRequest final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = DeleteVerticesRequest; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + DeleteVerticesRequest() : + space_id(0) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + DeleteVerticesRequest(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector> parts__arg, ::nebula::storage::cpp2::RequestCommon common__arg); + + DeleteVerticesRequest(DeleteVerticesRequest&&) = default; + + DeleteVerticesRequest(const DeleteVerticesRequest&) = default; + + + DeleteVerticesRequest& operator=(DeleteVerticesRequest&&) = default; + + DeleteVerticesRequest& operator=(const DeleteVerticesRequest&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::GraphSpaceID space_id; + private: + std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector> parts; + private: + ::nebula::storage::cpp2::RequestCommon common; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool space_id; + bool parts; + bool common; + } __isset = {}; + bool operator==(const DeleteVerticesRequest& rhs) const; +#ifndef SWIG + friend bool operator!=(const DeleteVerticesRequest& __x, const DeleteVerticesRequest& __y) { + return !(__x == __y); + } +#endif + bool operator<(const DeleteVerticesRequest& rhs) const; +#ifndef SWIG + friend bool operator>(const DeleteVerticesRequest& __x, const DeleteVerticesRequest& __y) { + return __y < __x; + } + friend bool operator<=(const DeleteVerticesRequest& __x, const DeleteVerticesRequest& __y) { + return !(__y < __x); + } + friend bool operator>=(const DeleteVerticesRequest& __x, const DeleteVerticesRequest& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const& { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const&& { + return {std::move(this->space_id), __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() & { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() && { + return {std::move(this->space_id), __isset.space_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template >> + FOLLY_ERASE ::apache::thrift::field_ref parts_ref() const& { + return {this->parts, __isset.parts}; + } + + template >> + FOLLY_ERASE ::apache::thrift::field_ref parts_ref() const&& { + return {std::move(this->parts), __isset.parts}; + } + + template >> + FOLLY_ERASE ::apache::thrift::field_ref parts_ref() & { + return {this->parts, __isset.parts}; + } + + template >> + FOLLY_ERASE ::apache::thrift::field_ref parts_ref() && { + return {std::move(this->parts), __isset.parts}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::optional_field_ref common_ref() const& { + return {this->common, __isset.common}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref common_ref() const&& { + return {std::move(this->common), __isset.common}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref common_ref() & { + return {this->common, __isset.common}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref common_ref() && { + return {std::move(this->common), __isset.common}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::GraphSpaceID get_space_id() const { + return space_id; + } + + ::nebula::cpp2::GraphSpaceID& set_space_id( ::nebula::cpp2::GraphSpaceID space_id_) { + space_id = space_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.space_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return space_id; + } + const std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector>& get_parts() const&; + std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector> get_parts() &&; + + template >> + std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector>& set_parts(T_DeleteVerticesRequest_parts_struct_setter&& parts_) { + parts = std::forward(parts_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.parts = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return parts; + } + const ::nebula::storage::cpp2::RequestCommon* get_common() const&; + ::nebula::storage::cpp2::RequestCommon* get_common() &; + ::nebula::storage::cpp2::RequestCommon* get_common() && = delete; + + template + ::nebula::storage::cpp2::RequestCommon& set_common(T_DeleteVerticesRequest_common_struct_setter&& common_) { + common = std::forward(common_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.common = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return common; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< DeleteVerticesRequest >; + friend void swap(DeleteVerticesRequest& a, DeleteVerticesRequest& b); +}; + +template +uint32_t DeleteVerticesRequest::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { +class DeleteEdgesRequest final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = DeleteEdgesRequest; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + DeleteEdgesRequest() : + space_id(0) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + DeleteEdgesRequest(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::storage::cpp2::EdgeKey>> parts__arg, ::nebula::storage::cpp2::RequestCommon common__arg); + + DeleteEdgesRequest(DeleteEdgesRequest&&) = default; + + DeleteEdgesRequest(const DeleteEdgesRequest&) = default; + + + DeleteEdgesRequest& operator=(DeleteEdgesRequest&&) = default; + + DeleteEdgesRequest& operator=(const DeleteEdgesRequest&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::GraphSpaceID space_id; + private: + std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::storage::cpp2::EdgeKey>> parts; + private: + ::nebula::storage::cpp2::RequestCommon common; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool space_id; + bool parts; + bool common; + } __isset = {}; + bool operator==(const DeleteEdgesRequest& rhs) const; +#ifndef SWIG + friend bool operator!=(const DeleteEdgesRequest& __x, const DeleteEdgesRequest& __y) { + return !(__x == __y); + } +#endif + bool operator<(const DeleteEdgesRequest& rhs) const; +#ifndef SWIG + friend bool operator>(const DeleteEdgesRequest& __x, const DeleteEdgesRequest& __y) { + return __y < __x; + } + friend bool operator<=(const DeleteEdgesRequest& __x, const DeleteEdgesRequest& __y) { + return !(__y < __x); + } + friend bool operator>=(const DeleteEdgesRequest& __x, const DeleteEdgesRequest& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const& { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const&& { + return {std::move(this->space_id), __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() & { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() && { + return {std::move(this->space_id), __isset.space_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template >> + FOLLY_ERASE ::apache::thrift::field_ref parts_ref() const& { + return {this->parts, __isset.parts}; + } + + template >> + FOLLY_ERASE ::apache::thrift::field_ref parts_ref() const&& { + return {std::move(this->parts), __isset.parts}; + } + + template >> + FOLLY_ERASE ::apache::thrift::field_ref parts_ref() & { + return {this->parts, __isset.parts}; + } + + template >> + FOLLY_ERASE ::apache::thrift::field_ref parts_ref() && { + return {std::move(this->parts), __isset.parts}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::optional_field_ref common_ref() const& { + return {this->common, __isset.common}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref common_ref() const&& { + return {std::move(this->common), __isset.common}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref common_ref() & { + return {this->common, __isset.common}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref common_ref() && { + return {std::move(this->common), __isset.common}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::GraphSpaceID get_space_id() const { + return space_id; + } + + ::nebula::cpp2::GraphSpaceID& set_space_id( ::nebula::cpp2::GraphSpaceID space_id_) { + space_id = space_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.space_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return space_id; + } + const std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::storage::cpp2::EdgeKey>>& get_parts() const&; + std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::storage::cpp2::EdgeKey>> get_parts() &&; + + template >> + std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::storage::cpp2::EdgeKey>>& set_parts(T_DeleteEdgesRequest_parts_struct_setter&& parts_) { + parts = std::forward(parts_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.parts = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return parts; + } + const ::nebula::storage::cpp2::RequestCommon* get_common() const&; + ::nebula::storage::cpp2::RequestCommon* get_common() &; + ::nebula::storage::cpp2::RequestCommon* get_common() && = delete; + + template + ::nebula::storage::cpp2::RequestCommon& set_common(T_DeleteEdgesRequest_common_struct_setter&& common_) { + common = std::forward(common_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.common = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return common; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< DeleteEdgesRequest >; + friend void swap(DeleteEdgesRequest& a, DeleteEdgesRequest& b); +}; + +template +uint32_t DeleteEdgesRequest::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { +class DelTags final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = DelTags; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + DelTags() {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + DelTags(apache::thrift::FragileConstructor, nebula::Value id__arg, ::std::vector< ::nebula::cpp2::TagID> tags__arg); + + DelTags(DelTags&&) = default; + + DelTags(const DelTags&) = default; + + + DelTags& operator=(DelTags&&) = default; + + DelTags& operator=(const DelTags&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + nebula::Value id; + private: + ::std::vector< ::nebula::cpp2::TagID> tags; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool id; + bool tags; + } __isset = {}; + bool operator==(const DelTags& rhs) const; +#ifndef SWIG + friend bool operator!=(const DelTags& __x, const DelTags& __y) { + return !(__x == __y); + } +#endif + bool operator<(const DelTags& rhs) const; +#ifndef SWIG + friend bool operator>(const DelTags& __x, const DelTags& __y) { + return __y < __x; + } + friend bool operator<=(const DelTags& __x, const DelTags& __y) { + return !(__y < __x); + } + friend bool operator>=(const DelTags& __x, const DelTags& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref id_ref() const& { + return {this->id, __isset.id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref id_ref() const&& { + return {std::move(this->id), __isset.id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref id_ref() & { + return {this->id, __isset.id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref id_ref() && { + return {std::move(this->id), __isset.id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::field_ref tags_ref() const& { + return {this->tags, __isset.tags}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref tags_ref() const&& { + return {std::move(this->tags), __isset.tags}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref tags_ref() & { + return {this->tags, __isset.tags}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref tags_ref() && { + return {std::move(this->tags), __isset.tags}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + const nebula::Value& get_id() const&; + nebula::Value get_id() &&; + + template + nebula::Value& set_id(T_DelTags_id_struct_setter&& id_) { + id = std::forward(id_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return id; + } + const ::std::vector< ::nebula::cpp2::TagID>& get_tags() const&; + ::std::vector< ::nebula::cpp2::TagID> get_tags() &&; + + template > + ::std::vector< ::nebula::cpp2::TagID>& set_tags(T_DelTags_tags_struct_setter&& tags_) { + tags = std::forward(tags_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.tags = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return tags; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< DelTags >; + friend void swap(DelTags& a, DelTags& b); +}; + +template +uint32_t DelTags::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { +class DeleteTagsRequest final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = DeleteTagsRequest; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + DeleteTagsRequest() : + space_id(0) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + DeleteTagsRequest(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::storage::cpp2::DelTags>> parts__arg, ::nebula::storage::cpp2::RequestCommon common__arg); + + DeleteTagsRequest(DeleteTagsRequest&&) = default; + + DeleteTagsRequest(const DeleteTagsRequest&) = default; + + + DeleteTagsRequest& operator=(DeleteTagsRequest&&) = default; + + DeleteTagsRequest& operator=(const DeleteTagsRequest&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::GraphSpaceID space_id; + private: + std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::storage::cpp2::DelTags>> parts; + private: + ::nebula::storage::cpp2::RequestCommon common; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool space_id; + bool parts; + bool common; + } __isset = {}; + bool operator==(const DeleteTagsRequest& rhs) const; +#ifndef SWIG + friend bool operator!=(const DeleteTagsRequest& __x, const DeleteTagsRequest& __y) { + return !(__x == __y); + } +#endif + bool operator<(const DeleteTagsRequest& rhs) const; +#ifndef SWIG + friend bool operator>(const DeleteTagsRequest& __x, const DeleteTagsRequest& __y) { + return __y < __x; + } + friend bool operator<=(const DeleteTagsRequest& __x, const DeleteTagsRequest& __y) { + return !(__y < __x); + } + friend bool operator>=(const DeleteTagsRequest& __x, const DeleteTagsRequest& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const& { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const&& { + return {std::move(this->space_id), __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() & { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() && { + return {std::move(this->space_id), __isset.space_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template >> + FOLLY_ERASE ::apache::thrift::field_ref parts_ref() const& { + return {this->parts, __isset.parts}; + } + + template >> + FOLLY_ERASE ::apache::thrift::field_ref parts_ref() const&& { + return {std::move(this->parts), __isset.parts}; + } + + template >> + FOLLY_ERASE ::apache::thrift::field_ref parts_ref() & { + return {this->parts, __isset.parts}; + } + + template >> + FOLLY_ERASE ::apache::thrift::field_ref parts_ref() && { + return {std::move(this->parts), __isset.parts}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::optional_field_ref common_ref() const& { + return {this->common, __isset.common}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref common_ref() const&& { + return {std::move(this->common), __isset.common}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref common_ref() & { + return {this->common, __isset.common}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref common_ref() && { + return {std::move(this->common), __isset.common}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::GraphSpaceID get_space_id() const { + return space_id; + } + + ::nebula::cpp2::GraphSpaceID& set_space_id( ::nebula::cpp2::GraphSpaceID space_id_) { + space_id = space_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.space_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return space_id; + } + const std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::storage::cpp2::DelTags>>& get_parts() const&; + std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::storage::cpp2::DelTags>> get_parts() &&; + + template >> + std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::storage::cpp2::DelTags>>& set_parts(T_DeleteTagsRequest_parts_struct_setter&& parts_) { + parts = std::forward(parts_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.parts = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return parts; + } + const ::nebula::storage::cpp2::RequestCommon* get_common() const&; + ::nebula::storage::cpp2::RequestCommon* get_common() &; + ::nebula::storage::cpp2::RequestCommon* get_common() && = delete; + + template + ::nebula::storage::cpp2::RequestCommon& set_common(T_DeleteTagsRequest_common_struct_setter&& common_) { + common = std::forward(common_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.common = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return common; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< DeleteTagsRequest >; + friend void swap(DeleteTagsRequest& a, DeleteTagsRequest& b); +}; + +template +uint32_t DeleteTagsRequest::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { +class UpdateResponse final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = UpdateResponse; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + UpdateResponse() {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + UpdateResponse(apache::thrift::FragileConstructor, ::nebula::storage::cpp2::ResponseCommon result__arg, nebula::DataSet props__arg); + + UpdateResponse(UpdateResponse&&) = default; + + UpdateResponse(const UpdateResponse&) = default; + + + UpdateResponse& operator=(UpdateResponse&&) = default; + + UpdateResponse& operator=(const UpdateResponse&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + public: + ::nebula::storage::cpp2::ResponseCommon result; + private: + nebula::DataSet props; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool props; + } __isset = {}; + bool operator==(const UpdateResponse& rhs) const; +#ifndef SWIG + friend bool operator!=(const UpdateResponse& __x, const UpdateResponse& __y) { + return !(__x == __y); + } +#endif + bool operator<(const UpdateResponse& rhs) const; +#ifndef SWIG + friend bool operator>(const UpdateResponse& __x, const UpdateResponse& __y) { + return __y < __x; + } + friend bool operator<=(const UpdateResponse& __x, const UpdateResponse& __y) { + return !(__y < __x); + } + friend bool operator>=(const UpdateResponse& __x, const UpdateResponse& __y) { + return !(__x < __y); + } +#endif + template + FOLLY_ERASE ::apache::thrift::required_field_ref result_ref() const& { + return ::apache::thrift::required_field_ref{this->result}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref result_ref() const&& { + return ::apache::thrift::required_field_ref{std::move(this->result)}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref result_ref() & { + return ::apache::thrift::required_field_ref{this->result}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref result_ref() && { + return ::apache::thrift::required_field_ref{std::move(this->result)}; + } + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::optional_field_ref props_ref() const& { + return {this->props, __isset.props}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref props_ref() const&& { + return {std::move(this->props), __isset.props}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref props_ref() & { + return {this->props, __isset.props}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref props_ref() && { + return {std::move(this->props), __isset.props}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + const ::nebula::storage::cpp2::ResponseCommon& get_result() const&; + ::nebula::storage::cpp2::ResponseCommon get_result() &&; + + template + ::nebula::storage::cpp2::ResponseCommon& set_result(T_UpdateResponse_result_struct_setter&& result_) { + result = std::forward(result_); + return result; + } + const nebula::DataSet* get_props() const&; + nebula::DataSet* get_props() &; + nebula::DataSet* get_props() && = delete; + + template + nebula::DataSet& set_props(T_UpdateResponse_props_struct_setter&& props_) { + props = std::forward(props_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.props = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return props; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< UpdateResponse >; + friend void swap(UpdateResponse& a, UpdateResponse& b); +}; + +template +uint32_t UpdateResponse::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { +class UpdatedProp final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = UpdatedProp; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + UpdatedProp() {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + UpdatedProp(apache::thrift::FragileConstructor, ::std::string name__arg, ::std::string value__arg); + + UpdatedProp(UpdatedProp&&) = default; + + UpdatedProp(const UpdatedProp&) = default; + + + UpdatedProp& operator=(UpdatedProp&&) = default; + + UpdatedProp& operator=(const UpdatedProp&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + public: + ::std::string name; + public: + ::std::string value; + + public: + bool operator==(const UpdatedProp& rhs) const; +#ifndef SWIG + friend bool operator!=(const UpdatedProp& __x, const UpdatedProp& __y) { + return !(__x == __y); + } +#endif + bool operator<(const UpdatedProp& rhs) const; +#ifndef SWIG + friend bool operator>(const UpdatedProp& __x, const UpdatedProp& __y) { + return __y < __x; + } + friend bool operator<=(const UpdatedProp& __x, const UpdatedProp& __y) { + return !(__y < __x); + } + friend bool operator>=(const UpdatedProp& __x, const UpdatedProp& __y) { + return !(__x < __y); + } +#endif + template + FOLLY_ERASE ::apache::thrift::required_field_ref name_ref() const& { + return ::apache::thrift::required_field_ref{this->name}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref name_ref() const&& { + return ::apache::thrift::required_field_ref{std::move(this->name)}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref name_ref() & { + return ::apache::thrift::required_field_ref{this->name}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref name_ref() && { + return ::apache::thrift::required_field_ref{std::move(this->name)}; + } + template + FOLLY_ERASE ::apache::thrift::required_field_ref value_ref() const& { + return ::apache::thrift::required_field_ref{this->value}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref value_ref() const&& { + return ::apache::thrift::required_field_ref{std::move(this->value)}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref value_ref() & { + return ::apache::thrift::required_field_ref{this->value}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref value_ref() && { + return ::apache::thrift::required_field_ref{std::move(this->value)}; + } + + const ::std::string& get_name() const& { + return name; + } + + ::std::string get_name() && { + return std::move(name); + } + + template + ::std::string& set_name(T_UpdatedProp_name_struct_setter&& name_) { + name = std::forward(name_); + return name; + } + + const ::std::string& get_value() const& { + return value; + } + + ::std::string get_value() && { + return std::move(value); + } + + template + ::std::string& set_value(T_UpdatedProp_value_struct_setter&& value_) { + value = std::forward(value_); + return value; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< UpdatedProp >; + friend void swap(UpdatedProp& a, UpdatedProp& b); +}; + +template +uint32_t UpdatedProp::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { +class UpdateVertexRequest final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = UpdateVertexRequest; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + + UpdateVertexRequest(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + UpdateVertexRequest(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, ::nebula::cpp2::PartitionID part_id__arg, nebula::Value vertex_id__arg, ::nebula::cpp2::TagID tag_id__arg, ::std::vector< ::nebula::storage::cpp2::UpdatedProp> updated_props__arg, bool insertable__arg, ::std::vector<::std::string> return_props__arg, ::std::string condition__arg, ::nebula::storage::cpp2::RequestCommon common__arg); + + UpdateVertexRequest(UpdateVertexRequest&&) = default; + + UpdateVertexRequest(const UpdateVertexRequest&) = default; + + + UpdateVertexRequest& operator=(UpdateVertexRequest&&) = default; + + UpdateVertexRequest& operator=(const UpdateVertexRequest&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + + ~UpdateVertexRequest(); + + private: + ::nebula::cpp2::GraphSpaceID space_id; + private: + ::nebula::cpp2::PartitionID part_id; + private: + nebula::Value vertex_id; + public: + ::nebula::cpp2::TagID tag_id; + private: + ::std::vector< ::nebula::storage::cpp2::UpdatedProp> updated_props; + private: + bool insertable; + private: + ::std::vector<::std::string> return_props; + private: + ::std::string condition; + private: + ::nebula::storage::cpp2::RequestCommon common; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool space_id; + bool part_id; + bool vertex_id; + bool updated_props; + bool insertable; + bool return_props; + bool condition; + bool common; + } __isset = {}; + bool operator==(const UpdateVertexRequest& rhs) const; +#ifndef SWIG + friend bool operator!=(const UpdateVertexRequest& __x, const UpdateVertexRequest& __y) { + return !(__x == __y); + } +#endif + bool operator<(const UpdateVertexRequest& rhs) const; +#ifndef SWIG + friend bool operator>(const UpdateVertexRequest& __x, const UpdateVertexRequest& __y) { + return __y < __x; + } + friend bool operator<=(const UpdateVertexRequest& __x, const UpdateVertexRequest& __y) { + return !(__y < __x); + } + friend bool operator>=(const UpdateVertexRequest& __x, const UpdateVertexRequest& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const& { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const&& { + return {std::move(this->space_id), __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() & { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() && { + return {std::move(this->space_id), __isset.space_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref part_id_ref() const& { + return {this->part_id, __isset.part_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref part_id_ref() const&& { + return {std::move(this->part_id), __isset.part_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref part_id_ref() & { + return {this->part_id, __isset.part_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref part_id_ref() && { + return {std::move(this->part_id), __isset.part_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref vertex_id_ref() const& { + return {this->vertex_id, __isset.vertex_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref vertex_id_ref() const&& { + return {std::move(this->vertex_id), __isset.vertex_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref vertex_id_ref() & { + return {this->vertex_id, __isset.vertex_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref vertex_id_ref() && { + return {std::move(this->vertex_id), __isset.vertex_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + template + FOLLY_ERASE ::apache::thrift::required_field_ref tag_id_ref() const& { + return ::apache::thrift::required_field_ref{this->tag_id}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref tag_id_ref() const&& { + return ::apache::thrift::required_field_ref{std::move(this->tag_id)}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref tag_id_ref() & { + return ::apache::thrift::required_field_ref{this->tag_id}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref tag_id_ref() && { + return ::apache::thrift::required_field_ref{std::move(this->tag_id)}; + } + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::field_ref updated_props_ref() const& { + return {this->updated_props, __isset.updated_props}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref updated_props_ref() const&& { + return {std::move(this->updated_props), __isset.updated_props}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref updated_props_ref() & { + return {this->updated_props, __isset.updated_props}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref updated_props_ref() && { + return {std::move(this->updated_props), __isset.updated_props}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::optional_field_ref insertable_ref() const& { + return {this->insertable, __isset.insertable}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref insertable_ref() const&& { + return {std::move(this->insertable), __isset.insertable}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref insertable_ref() & { + return {this->insertable, __isset.insertable}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref insertable_ref() && { + return {std::move(this->insertable), __isset.insertable}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::optional_field_ref return_props_ref() const& { + return {this->return_props, __isset.return_props}; + } + + template > + FOLLY_ERASE ::apache::thrift::optional_field_ref return_props_ref() const&& { + return {std::move(this->return_props), __isset.return_props}; + } + + template > + FOLLY_ERASE ::apache::thrift::optional_field_ref return_props_ref() & { + return {this->return_props, __isset.return_props}; + } + + template > + FOLLY_ERASE ::apache::thrift::optional_field_ref return_props_ref() && { + return {std::move(this->return_props), __isset.return_props}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::optional_field_ref condition_ref() const& { + return {this->condition, __isset.condition}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref condition_ref() const&& { + return {std::move(this->condition), __isset.condition}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref condition_ref() & { + return {this->condition, __isset.condition}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref condition_ref() && { + return {std::move(this->condition), __isset.condition}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::optional_field_ref common_ref() const& { + return {this->common, __isset.common}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref common_ref() const&& { + return {std::move(this->common), __isset.common}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref common_ref() & { + return {this->common, __isset.common}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref common_ref() && { + return {std::move(this->common), __isset.common}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::GraphSpaceID get_space_id() const { + return space_id; + } + + ::nebula::cpp2::GraphSpaceID& set_space_id( ::nebula::cpp2::GraphSpaceID space_id_) { + space_id = space_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.space_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return space_id; + } + + ::nebula::cpp2::PartitionID get_part_id() const { + return part_id; + } + + ::nebula::cpp2::PartitionID& set_part_id( ::nebula::cpp2::PartitionID part_id_) { + part_id = part_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.part_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return part_id; + } + const nebula::Value& get_vertex_id() const&; + nebula::Value get_vertex_id() &&; + + template + nebula::Value& set_vertex_id(T_UpdateVertexRequest_vertex_id_struct_setter&& vertex_id_) { + vertex_id = std::forward(vertex_id_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.vertex_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return vertex_id; + } + + ::nebula::cpp2::TagID get_tag_id() const { + return tag_id; + } + + ::nebula::cpp2::TagID& set_tag_id( ::nebula::cpp2::TagID tag_id_) { + tag_id = tag_id_; + return tag_id; + } + const ::std::vector< ::nebula::storage::cpp2::UpdatedProp>& get_updated_props() const&; + ::std::vector< ::nebula::storage::cpp2::UpdatedProp> get_updated_props() &&; + + template > + ::std::vector< ::nebula::storage::cpp2::UpdatedProp>& set_updated_props(T_UpdateVertexRequest_updated_props_struct_setter&& updated_props_) { + updated_props = std::forward(updated_props_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.updated_props = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return updated_props; + } + + const bool* get_insertable() const& { + return insertable_ref() ? std::addressof(insertable) : nullptr; + } + + bool* get_insertable() & { + return insertable_ref() ? std::addressof(insertable) : nullptr; + } + bool* get_insertable() && = delete; + + bool& set_insertable(bool insertable_) { + insertable = insertable_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.insertable = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return insertable; + } + const ::std::vector<::std::string>* get_return_props() const&; + ::std::vector<::std::string>* get_return_props() &; + ::std::vector<::std::string>* get_return_props() && = delete; + + template > + ::std::vector<::std::string>& set_return_props(T_UpdateVertexRequest_return_props_struct_setter&& return_props_) { + return_props = std::forward(return_props_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.return_props = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return return_props; + } + + const ::std::string* get_condition() const& { + return condition_ref() ? std::addressof(condition) : nullptr; + } + + ::std::string* get_condition() & { + return condition_ref() ? std::addressof(condition) : nullptr; + } + ::std::string* get_condition() && = delete; + + template + ::std::string& set_condition(T_UpdateVertexRequest_condition_struct_setter&& condition_) { + condition = std::forward(condition_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.condition = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return condition; + } + const ::nebula::storage::cpp2::RequestCommon* get_common() const&; + ::nebula::storage::cpp2::RequestCommon* get_common() &; + ::nebula::storage::cpp2::RequestCommon* get_common() && = delete; + + template + ::nebula::storage::cpp2::RequestCommon& set_common(T_UpdateVertexRequest_common_struct_setter&& common_) { + common = std::forward(common_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.common = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return common; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< UpdateVertexRequest >; + friend void swap(UpdateVertexRequest& a, UpdateVertexRequest& b); +}; + +template +uint32_t UpdateVertexRequest::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { +class UpdateEdgeRequest final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = UpdateEdgeRequest; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + + UpdateEdgeRequest(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + UpdateEdgeRequest(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, ::nebula::cpp2::PartitionID part_id__arg, ::nebula::storage::cpp2::EdgeKey edge_key__arg, ::std::vector< ::nebula::storage::cpp2::UpdatedProp> updated_props__arg, bool insertable__arg, ::std::vector<::std::string> return_props__arg, ::std::string condition__arg, ::nebula::storage::cpp2::RequestCommon common__arg); + + UpdateEdgeRequest(UpdateEdgeRequest&&) = default; + + UpdateEdgeRequest(const UpdateEdgeRequest&) = default; + + + UpdateEdgeRequest& operator=(UpdateEdgeRequest&&) = default; + + UpdateEdgeRequest& operator=(const UpdateEdgeRequest&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + + ~UpdateEdgeRequest(); + + private: + ::nebula::cpp2::GraphSpaceID space_id; + private: + ::nebula::cpp2::PartitionID part_id; + private: + ::nebula::storage::cpp2::EdgeKey edge_key; + private: + ::std::vector< ::nebula::storage::cpp2::UpdatedProp> updated_props; + private: + bool insertable; + private: + ::std::vector<::std::string> return_props; + private: + ::std::string condition; + private: + ::nebula::storage::cpp2::RequestCommon common; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool space_id; + bool part_id; + bool edge_key; + bool updated_props; + bool insertable; + bool return_props; + bool condition; + bool common; + } __isset = {}; + bool operator==(const UpdateEdgeRequest& rhs) const; +#ifndef SWIG + friend bool operator!=(const UpdateEdgeRequest& __x, const UpdateEdgeRequest& __y) { + return !(__x == __y); + } +#endif + bool operator<(const UpdateEdgeRequest& rhs) const; +#ifndef SWIG + friend bool operator>(const UpdateEdgeRequest& __x, const UpdateEdgeRequest& __y) { + return __y < __x; + } + friend bool operator<=(const UpdateEdgeRequest& __x, const UpdateEdgeRequest& __y) { + return !(__y < __x); + } + friend bool operator>=(const UpdateEdgeRequest& __x, const UpdateEdgeRequest& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const& { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const&& { + return {std::move(this->space_id), __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() & { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() && { + return {std::move(this->space_id), __isset.space_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref part_id_ref() const& { + return {this->part_id, __isset.part_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref part_id_ref() const&& { + return {std::move(this->part_id), __isset.part_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref part_id_ref() & { + return {this->part_id, __isset.part_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref part_id_ref() && { + return {std::move(this->part_id), __isset.part_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref edge_key_ref() const& { + return {this->edge_key, __isset.edge_key}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref edge_key_ref() const&& { + return {std::move(this->edge_key), __isset.edge_key}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref edge_key_ref() & { + return {this->edge_key, __isset.edge_key}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref edge_key_ref() && { + return {std::move(this->edge_key), __isset.edge_key}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::field_ref updated_props_ref() const& { + return {this->updated_props, __isset.updated_props}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref updated_props_ref() const&& { + return {std::move(this->updated_props), __isset.updated_props}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref updated_props_ref() & { + return {this->updated_props, __isset.updated_props}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref updated_props_ref() && { + return {std::move(this->updated_props), __isset.updated_props}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::optional_field_ref insertable_ref() const& { + return {this->insertable, __isset.insertable}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref insertable_ref() const&& { + return {std::move(this->insertable), __isset.insertable}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref insertable_ref() & { + return {this->insertable, __isset.insertable}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref insertable_ref() && { + return {std::move(this->insertable), __isset.insertable}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::optional_field_ref return_props_ref() const& { + return {this->return_props, __isset.return_props}; + } + + template > + FOLLY_ERASE ::apache::thrift::optional_field_ref return_props_ref() const&& { + return {std::move(this->return_props), __isset.return_props}; + } + + template > + FOLLY_ERASE ::apache::thrift::optional_field_ref return_props_ref() & { + return {this->return_props, __isset.return_props}; + } + + template > + FOLLY_ERASE ::apache::thrift::optional_field_ref return_props_ref() && { + return {std::move(this->return_props), __isset.return_props}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::optional_field_ref condition_ref() const& { + return {this->condition, __isset.condition}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref condition_ref() const&& { + return {std::move(this->condition), __isset.condition}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref condition_ref() & { + return {this->condition, __isset.condition}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref condition_ref() && { + return {std::move(this->condition), __isset.condition}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::optional_field_ref common_ref() const& { + return {this->common, __isset.common}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref common_ref() const&& { + return {std::move(this->common), __isset.common}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref common_ref() & { + return {this->common, __isset.common}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref common_ref() && { + return {std::move(this->common), __isset.common}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::GraphSpaceID get_space_id() const { + return space_id; + } + + ::nebula::cpp2::GraphSpaceID& set_space_id( ::nebula::cpp2::GraphSpaceID space_id_) { + space_id = space_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.space_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return space_id; + } + + ::nebula::cpp2::PartitionID get_part_id() const { + return part_id; + } + + ::nebula::cpp2::PartitionID& set_part_id( ::nebula::cpp2::PartitionID part_id_) { + part_id = part_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.part_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return part_id; + } + const ::nebula::storage::cpp2::EdgeKey& get_edge_key() const&; + ::nebula::storage::cpp2::EdgeKey get_edge_key() &&; + + template + ::nebula::storage::cpp2::EdgeKey& set_edge_key(T_UpdateEdgeRequest_edge_key_struct_setter&& edge_key_) { + edge_key = std::forward(edge_key_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.edge_key = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return edge_key; + } + const ::std::vector< ::nebula::storage::cpp2::UpdatedProp>& get_updated_props() const&; + ::std::vector< ::nebula::storage::cpp2::UpdatedProp> get_updated_props() &&; + + template > + ::std::vector< ::nebula::storage::cpp2::UpdatedProp>& set_updated_props(T_UpdateEdgeRequest_updated_props_struct_setter&& updated_props_) { + updated_props = std::forward(updated_props_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.updated_props = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return updated_props; + } + + const bool* get_insertable() const& { + return insertable_ref() ? std::addressof(insertable) : nullptr; + } + + bool* get_insertable() & { + return insertable_ref() ? std::addressof(insertable) : nullptr; + } + bool* get_insertable() && = delete; + + bool& set_insertable(bool insertable_) { + insertable = insertable_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.insertable = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return insertable; + } + const ::std::vector<::std::string>* get_return_props() const&; + ::std::vector<::std::string>* get_return_props() &; + ::std::vector<::std::string>* get_return_props() && = delete; + + template > + ::std::vector<::std::string>& set_return_props(T_UpdateEdgeRequest_return_props_struct_setter&& return_props_) { + return_props = std::forward(return_props_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.return_props = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return return_props; + } + + const ::std::string* get_condition() const& { + return condition_ref() ? std::addressof(condition) : nullptr; + } + + ::std::string* get_condition() & { + return condition_ref() ? std::addressof(condition) : nullptr; + } + ::std::string* get_condition() && = delete; + + template + ::std::string& set_condition(T_UpdateEdgeRequest_condition_struct_setter&& condition_) { + condition = std::forward(condition_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.condition = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return condition; + } + const ::nebula::storage::cpp2::RequestCommon* get_common() const&; + ::nebula::storage::cpp2::RequestCommon* get_common() &; + ::nebula::storage::cpp2::RequestCommon* get_common() && = delete; + + template + ::nebula::storage::cpp2::RequestCommon& set_common(T_UpdateEdgeRequest_common_struct_setter&& common_) { + common = std::forward(common_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.common = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return common; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< UpdateEdgeRequest >; + friend void swap(UpdateEdgeRequest& a, UpdateEdgeRequest& b); +}; + +template +uint32_t UpdateEdgeRequest::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { +class GetUUIDReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = GetUUIDReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + GetUUIDReq() : + space_id(0), + part_id(0) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + GetUUIDReq(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, ::nebula::cpp2::PartitionID part_id__arg, ::std::string name__arg, ::nebula::storage::cpp2::RequestCommon common__arg); + + GetUUIDReq(GetUUIDReq&&) = default; + + GetUUIDReq(const GetUUIDReq&) = default; + + + GetUUIDReq& operator=(GetUUIDReq&&) = default; + + GetUUIDReq& operator=(const GetUUIDReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::GraphSpaceID space_id; + private: + ::nebula::cpp2::PartitionID part_id; + private: + ::std::string name; + private: + ::nebula::storage::cpp2::RequestCommon common; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool space_id; + bool part_id; + bool name; + bool common; + } __isset = {}; + bool operator==(const GetUUIDReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const GetUUIDReq& __x, const GetUUIDReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const GetUUIDReq& rhs) const; +#ifndef SWIG + friend bool operator>(const GetUUIDReq& __x, const GetUUIDReq& __y) { + return __y < __x; + } + friend bool operator<=(const GetUUIDReq& __x, const GetUUIDReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const GetUUIDReq& __x, const GetUUIDReq& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const& { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const&& { + return {std::move(this->space_id), __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() & { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() && { + return {std::move(this->space_id), __isset.space_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref part_id_ref() const& { + return {this->part_id, __isset.part_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref part_id_ref() const&& { + return {std::move(this->part_id), __isset.part_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref part_id_ref() & { + return {this->part_id, __isset.part_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref part_id_ref() && { + return {std::move(this->part_id), __isset.part_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref name_ref() const& { + return {this->name, __isset.name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref name_ref() const&& { + return {std::move(this->name), __isset.name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref name_ref() & { + return {this->name, __isset.name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref name_ref() && { + return {std::move(this->name), __isset.name}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::optional_field_ref common_ref() const& { + return {this->common, __isset.common}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref common_ref() const&& { + return {std::move(this->common), __isset.common}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref common_ref() & { + return {this->common, __isset.common}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref common_ref() && { + return {std::move(this->common), __isset.common}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::GraphSpaceID get_space_id() const { + return space_id; + } + + ::nebula::cpp2::GraphSpaceID& set_space_id( ::nebula::cpp2::GraphSpaceID space_id_) { + space_id = space_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.space_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return space_id; + } + + ::nebula::cpp2::PartitionID get_part_id() const { + return part_id; + } + + ::nebula::cpp2::PartitionID& set_part_id( ::nebula::cpp2::PartitionID part_id_) { + part_id = part_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.part_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return part_id; + } + + const ::std::string& get_name() const& { + return name; + } + + ::std::string get_name() && { + return std::move(name); + } + + template + ::std::string& set_name(T_GetUUIDReq_name_struct_setter&& name_) { + name = std::forward(name_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.name = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return name; + } + const ::nebula::storage::cpp2::RequestCommon* get_common() const&; + ::nebula::storage::cpp2::RequestCommon* get_common() &; + ::nebula::storage::cpp2::RequestCommon* get_common() && = delete; + + template + ::nebula::storage::cpp2::RequestCommon& set_common(T_GetUUIDReq_common_struct_setter&& common_) { + common = std::forward(common_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.common = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return common; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< GetUUIDReq >; + friend void swap(GetUUIDReq& a, GetUUIDReq& b); +}; + +template +uint32_t GetUUIDReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { +class GetUUIDResp final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = GetUUIDResp; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + GetUUIDResp() {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + GetUUIDResp(apache::thrift::FragileConstructor, ::nebula::storage::cpp2::ResponseCommon result__arg, nebula::Value id__arg); + + GetUUIDResp(GetUUIDResp&&) = default; + + GetUUIDResp(const GetUUIDResp&) = default; + + + GetUUIDResp& operator=(GetUUIDResp&&) = default; + + GetUUIDResp& operator=(const GetUUIDResp&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + public: + ::nebula::storage::cpp2::ResponseCommon result; + private: + nebula::Value id; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool id; + } __isset = {}; + bool operator==(const GetUUIDResp& rhs) const; +#ifndef SWIG + friend bool operator!=(const GetUUIDResp& __x, const GetUUIDResp& __y) { + return !(__x == __y); + } +#endif + bool operator<(const GetUUIDResp& rhs) const; +#ifndef SWIG + friend bool operator>(const GetUUIDResp& __x, const GetUUIDResp& __y) { + return __y < __x; + } + friend bool operator<=(const GetUUIDResp& __x, const GetUUIDResp& __y) { + return !(__y < __x); + } + friend bool operator>=(const GetUUIDResp& __x, const GetUUIDResp& __y) { + return !(__x < __y); + } +#endif + template + FOLLY_ERASE ::apache::thrift::required_field_ref result_ref() const& { + return ::apache::thrift::required_field_ref{this->result}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref result_ref() const&& { + return ::apache::thrift::required_field_ref{std::move(this->result)}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref result_ref() & { + return ::apache::thrift::required_field_ref{this->result}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref result_ref() && { + return ::apache::thrift::required_field_ref{std::move(this->result)}; + } + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref id_ref() const& { + return {this->id, __isset.id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref id_ref() const&& { + return {std::move(this->id), __isset.id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref id_ref() & { + return {this->id, __isset.id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref id_ref() && { + return {std::move(this->id), __isset.id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + const ::nebula::storage::cpp2::ResponseCommon& get_result() const&; + ::nebula::storage::cpp2::ResponseCommon get_result() &&; + + template + ::nebula::storage::cpp2::ResponseCommon& set_result(T_GetUUIDResp_result_struct_setter&& result_) { + result = std::forward(result_); + return result; + } + const nebula::Value& get_id() const&; + nebula::Value get_id() &&; + + template + nebula::Value& set_id(T_GetUUIDResp_id_struct_setter&& id_) { + id = std::forward(id_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return id; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< GetUUIDResp >; + friend void swap(GetUUIDResp& a, GetUUIDResp& b); +}; + +template +uint32_t GetUUIDResp::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { +class LookupIndexResp final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = LookupIndexResp; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + LookupIndexResp() {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + LookupIndexResp(apache::thrift::FragileConstructor, ::nebula::storage::cpp2::ResponseCommon result__arg, nebula::DataSet data__arg); + + LookupIndexResp(LookupIndexResp&&) = default; + + LookupIndexResp(const LookupIndexResp&) = default; + + + LookupIndexResp& operator=(LookupIndexResp&&) = default; + + LookupIndexResp& operator=(const LookupIndexResp&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + public: + ::nebula::storage::cpp2::ResponseCommon result; + private: + nebula::DataSet data; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool data; + } __isset = {}; + bool operator==(const LookupIndexResp& rhs) const; +#ifndef SWIG + friend bool operator!=(const LookupIndexResp& __x, const LookupIndexResp& __y) { + return !(__x == __y); + } +#endif + bool operator<(const LookupIndexResp& rhs) const; +#ifndef SWIG + friend bool operator>(const LookupIndexResp& __x, const LookupIndexResp& __y) { + return __y < __x; + } + friend bool operator<=(const LookupIndexResp& __x, const LookupIndexResp& __y) { + return !(__y < __x); + } + friend bool operator>=(const LookupIndexResp& __x, const LookupIndexResp& __y) { + return !(__x < __y); + } +#endif + template + FOLLY_ERASE ::apache::thrift::required_field_ref result_ref() const& { + return ::apache::thrift::required_field_ref{this->result}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref result_ref() const&& { + return ::apache::thrift::required_field_ref{std::move(this->result)}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref result_ref() & { + return ::apache::thrift::required_field_ref{this->result}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref result_ref() && { + return ::apache::thrift::required_field_ref{std::move(this->result)}; + } + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::optional_field_ref data_ref() const& { + return {this->data, __isset.data}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref data_ref() const&& { + return {std::move(this->data), __isset.data}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref data_ref() & { + return {this->data, __isset.data}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref data_ref() && { + return {std::move(this->data), __isset.data}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + const ::nebula::storage::cpp2::ResponseCommon& get_result() const&; + ::nebula::storage::cpp2::ResponseCommon get_result() &&; + + template + ::nebula::storage::cpp2::ResponseCommon& set_result(T_LookupIndexResp_result_struct_setter&& result_) { + result = std::forward(result_); + return result; + } + const nebula::DataSet* get_data() const&; + nebula::DataSet* get_data() &; + nebula::DataSet* get_data() && = delete; + + template + nebula::DataSet& set_data(T_LookupIndexResp_data_struct_setter&& data_) { + data = std::forward(data_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.data = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return data; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< LookupIndexResp >; + friend void swap(LookupIndexResp& a, LookupIndexResp& b); +}; + +template +uint32_t LookupIndexResp::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { +class IndexColumnHint final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = IndexColumnHint; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + IndexColumnHint() : + scan_type(static_cast< ::nebula::storage::cpp2::ScanType>(0)) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + IndexColumnHint(apache::thrift::FragileConstructor, ::std::string column_name__arg, ::nebula::storage::cpp2::ScanType scan_type__arg, nebula::Value begin_value__arg, nebula::Value end_value__arg); + + IndexColumnHint(IndexColumnHint&&) = default; + + IndexColumnHint(const IndexColumnHint&) = default; + + + IndexColumnHint& operator=(IndexColumnHint&&) = default; + + IndexColumnHint& operator=(const IndexColumnHint&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::std::string column_name; + private: + ::nebula::storage::cpp2::ScanType scan_type; + private: + nebula::Value begin_value; + private: + nebula::Value end_value; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool column_name; + bool scan_type; + bool begin_value; + bool end_value; + } __isset = {}; + bool operator==(const IndexColumnHint& rhs) const; +#ifndef SWIG + friend bool operator!=(const IndexColumnHint& __x, const IndexColumnHint& __y) { + return !(__x == __y); + } +#endif + bool operator<(const IndexColumnHint& rhs) const; +#ifndef SWIG + friend bool operator>(const IndexColumnHint& __x, const IndexColumnHint& __y) { + return __y < __x; + } + friend bool operator<=(const IndexColumnHint& __x, const IndexColumnHint& __y) { + return !(__y < __x); + } + friend bool operator>=(const IndexColumnHint& __x, const IndexColumnHint& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref column_name_ref() const& { + return {this->column_name, __isset.column_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref column_name_ref() const&& { + return {std::move(this->column_name), __isset.column_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref column_name_ref() & { + return {this->column_name, __isset.column_name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref column_name_ref() && { + return {std::move(this->column_name), __isset.column_name}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref scan_type_ref() const& { + return {this->scan_type, __isset.scan_type}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref scan_type_ref() const&& { + return {std::move(this->scan_type), __isset.scan_type}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref scan_type_ref() & { + return {this->scan_type, __isset.scan_type}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref scan_type_ref() && { + return {std::move(this->scan_type), __isset.scan_type}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref begin_value_ref() const& { + return {this->begin_value, __isset.begin_value}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref begin_value_ref() const&& { + return {std::move(this->begin_value), __isset.begin_value}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref begin_value_ref() & { + return {this->begin_value, __isset.begin_value}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref begin_value_ref() && { + return {std::move(this->begin_value), __isset.begin_value}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref end_value_ref() const& { + return {this->end_value, __isset.end_value}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref end_value_ref() const&& { + return {std::move(this->end_value), __isset.end_value}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref end_value_ref() & { + return {this->end_value, __isset.end_value}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref end_value_ref() && { + return {std::move(this->end_value), __isset.end_value}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + const ::std::string& get_column_name() const& { + return column_name; + } + + ::std::string get_column_name() && { + return std::move(column_name); + } + + template + ::std::string& set_column_name(T_IndexColumnHint_column_name_struct_setter&& column_name_) { + column_name = std::forward(column_name_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.column_name = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return column_name; + } + + ::nebula::storage::cpp2::ScanType get_scan_type() const { + return scan_type; + } + + ::nebula::storage::cpp2::ScanType& set_scan_type( ::nebula::storage::cpp2::ScanType scan_type_) { + scan_type = scan_type_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.scan_type = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return scan_type; + } + const nebula::Value& get_begin_value() const&; + nebula::Value get_begin_value() &&; + + template + nebula::Value& set_begin_value(T_IndexColumnHint_begin_value_struct_setter&& begin_value_) { + begin_value = std::forward(begin_value_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.begin_value = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return begin_value; + } + const nebula::Value& get_end_value() const&; + nebula::Value get_end_value() &&; + + template + nebula::Value& set_end_value(T_IndexColumnHint_end_value_struct_setter&& end_value_) { + end_value = std::forward(end_value_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.end_value = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return end_value; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< IndexColumnHint >; + friend void swap(IndexColumnHint& a, IndexColumnHint& b); +}; + +template +uint32_t IndexColumnHint::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { +class IndexQueryContext final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = IndexQueryContext; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + IndexQueryContext() : + index_id(0) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + IndexQueryContext(apache::thrift::FragileConstructor, ::nebula::cpp2::IndexID index_id__arg, ::std::string filter__arg, ::std::vector< ::nebula::storage::cpp2::IndexColumnHint> column_hints__arg); + + IndexQueryContext(IndexQueryContext&&) = default; + + IndexQueryContext(const IndexQueryContext&) = default; + + + IndexQueryContext& operator=(IndexQueryContext&&) = default; + + IndexQueryContext& operator=(const IndexQueryContext&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::IndexID index_id; + private: + ::std::string filter; + private: + ::std::vector< ::nebula::storage::cpp2::IndexColumnHint> column_hints; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool index_id; + bool filter; + bool column_hints; + } __isset = {}; + bool operator==(const IndexQueryContext& rhs) const; +#ifndef SWIG + friend bool operator!=(const IndexQueryContext& __x, const IndexQueryContext& __y) { + return !(__x == __y); + } +#endif + bool operator<(const IndexQueryContext& rhs) const; +#ifndef SWIG + friend bool operator>(const IndexQueryContext& __x, const IndexQueryContext& __y) { + return __y < __x; + } + friend bool operator<=(const IndexQueryContext& __x, const IndexQueryContext& __y) { + return !(__y < __x); + } + friend bool operator>=(const IndexQueryContext& __x, const IndexQueryContext& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref index_id_ref() const& { + return {this->index_id, __isset.index_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref index_id_ref() const&& { + return {std::move(this->index_id), __isset.index_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref index_id_ref() & { + return {this->index_id, __isset.index_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref index_id_ref() && { + return {std::move(this->index_id), __isset.index_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref filter_ref() const& { + return {this->filter, __isset.filter}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref filter_ref() const&& { + return {std::move(this->filter), __isset.filter}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref filter_ref() & { + return {this->filter, __isset.filter}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref filter_ref() && { + return {std::move(this->filter), __isset.filter}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::field_ref column_hints_ref() const& { + return {this->column_hints, __isset.column_hints}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref column_hints_ref() const&& { + return {std::move(this->column_hints), __isset.column_hints}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref column_hints_ref() & { + return {this->column_hints, __isset.column_hints}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref column_hints_ref() && { + return {std::move(this->column_hints), __isset.column_hints}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::IndexID get_index_id() const { + return index_id; + } + + ::nebula::cpp2::IndexID& set_index_id( ::nebula::cpp2::IndexID index_id_) { + index_id = index_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.index_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return index_id; + } + + const ::std::string& get_filter() const& { + return filter; + } + + ::std::string get_filter() && { + return std::move(filter); + } + + template + ::std::string& set_filter(T_IndexQueryContext_filter_struct_setter&& filter_) { + filter = std::forward(filter_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.filter = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return filter; + } + const ::std::vector< ::nebula::storage::cpp2::IndexColumnHint>& get_column_hints() const&; + ::std::vector< ::nebula::storage::cpp2::IndexColumnHint> get_column_hints() &&; + + template > + ::std::vector< ::nebula::storage::cpp2::IndexColumnHint>& set_column_hints(T_IndexQueryContext_column_hints_struct_setter&& column_hints_) { + column_hints = std::forward(column_hints_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.column_hints = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return column_hints; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< IndexQueryContext >; + friend void swap(IndexQueryContext& a, IndexQueryContext& b); +}; + +template +uint32_t IndexQueryContext::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { +class IndexSpec final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = IndexSpec; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + IndexSpec() {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + IndexSpec(apache::thrift::FragileConstructor, ::std::vector< ::nebula::storage::cpp2::IndexQueryContext> contexts__arg, ::nebula::cpp2::SchemaID schema_id__arg); + + IndexSpec(IndexSpec&&) = default; + + IndexSpec(const IndexSpec&) = default; + + + IndexSpec& operator=(IndexSpec&&) = default; + + IndexSpec& operator=(const IndexSpec&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + public: + ::std::vector< ::nebula::storage::cpp2::IndexQueryContext> contexts; + private: + ::nebula::cpp2::SchemaID schema_id; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool schema_id; + } __isset = {}; + bool operator==(const IndexSpec& rhs) const; +#ifndef SWIG + friend bool operator!=(const IndexSpec& __x, const IndexSpec& __y) { + return !(__x == __y); + } +#endif + bool operator<(const IndexSpec& rhs) const; +#ifndef SWIG + friend bool operator>(const IndexSpec& __x, const IndexSpec& __y) { + return __y < __x; + } + friend bool operator<=(const IndexSpec& __x, const IndexSpec& __y) { + return !(__y < __x); + } + friend bool operator>=(const IndexSpec& __x, const IndexSpec& __y) { + return !(__x < __y); + } +#endif + template > + FOLLY_ERASE ::apache::thrift::required_field_ref contexts_ref() const& { + return ::apache::thrift::required_field_ref{this->contexts}; + } + + template > + FOLLY_ERASE ::apache::thrift::required_field_ref contexts_ref() const&& { + return ::apache::thrift::required_field_ref{std::move(this->contexts)}; + } + + template > + FOLLY_ERASE ::apache::thrift::required_field_ref contexts_ref() & { + return ::apache::thrift::required_field_ref{this->contexts}; + } + + template > + FOLLY_ERASE ::apache::thrift::required_field_ref contexts_ref() && { + return ::apache::thrift::required_field_ref{std::move(this->contexts)}; + } + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref schema_id_ref() const& { + return {this->schema_id, __isset.schema_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref schema_id_ref() const&& { + return {std::move(this->schema_id), __isset.schema_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref schema_id_ref() & { + return {this->schema_id, __isset.schema_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref schema_id_ref() && { + return {std::move(this->schema_id), __isset.schema_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + const ::std::vector< ::nebula::storage::cpp2::IndexQueryContext>& get_contexts() const&; + ::std::vector< ::nebula::storage::cpp2::IndexQueryContext> get_contexts() &&; + + template > + ::std::vector< ::nebula::storage::cpp2::IndexQueryContext>& set_contexts(T_IndexSpec_contexts_struct_setter&& contexts_) { + contexts = std::forward(contexts_); + return contexts; + } + const ::nebula::cpp2::SchemaID& get_schema_id() const&; + ::nebula::cpp2::SchemaID get_schema_id() &&; + + template + ::nebula::cpp2::SchemaID& set_schema_id(T_IndexSpec_schema_id_struct_setter&& schema_id_) { + schema_id = std::forward(schema_id_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.schema_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return schema_id; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< IndexSpec >; + friend void swap(IndexSpec& a, IndexSpec& b); +}; + +template +uint32_t IndexSpec::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { +class LookupIndexRequest final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = LookupIndexRequest; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + + LookupIndexRequest(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + LookupIndexRequest(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, ::std::vector< ::nebula::cpp2::PartitionID> parts__arg, ::nebula::storage::cpp2::IndexSpec indices__arg, ::std::vector<::std::string> return_columns__arg, ::nebula::storage::cpp2::RequestCommon common__arg, int64_t limit__arg); + + LookupIndexRequest(LookupIndexRequest&&) = default; + + LookupIndexRequest(const LookupIndexRequest&) = default; + + + LookupIndexRequest& operator=(LookupIndexRequest&&) = default; + + LookupIndexRequest& operator=(const LookupIndexRequest&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + + ~LookupIndexRequest(); + + public: + ::nebula::cpp2::GraphSpaceID space_id; + public: + ::std::vector< ::nebula::cpp2::PartitionID> parts; + private: + ::nebula::storage::cpp2::IndexSpec indices; + private: + ::std::vector<::std::string> return_columns; + private: + ::nebula::storage::cpp2::RequestCommon common; + private: + int64_t limit; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool indices; + bool return_columns; + bool common; + bool limit; + } __isset = {}; + bool operator==(const LookupIndexRequest& rhs) const; +#ifndef SWIG + friend bool operator!=(const LookupIndexRequest& __x, const LookupIndexRequest& __y) { + return !(__x == __y); + } +#endif + bool operator<(const LookupIndexRequest& rhs) const; +#ifndef SWIG + friend bool operator>(const LookupIndexRequest& __x, const LookupIndexRequest& __y) { + return __y < __x; + } + friend bool operator<=(const LookupIndexRequest& __x, const LookupIndexRequest& __y) { + return !(__y < __x); + } + friend bool operator>=(const LookupIndexRequest& __x, const LookupIndexRequest& __y) { + return !(__x < __y); + } +#endif + template + FOLLY_ERASE ::apache::thrift::required_field_ref space_id_ref() const& { + return ::apache::thrift::required_field_ref{this->space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref space_id_ref() const&& { + return ::apache::thrift::required_field_ref{std::move(this->space_id)}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref space_id_ref() & { + return ::apache::thrift::required_field_ref{this->space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref space_id_ref() && { + return ::apache::thrift::required_field_ref{std::move(this->space_id)}; + } + template > + FOLLY_ERASE ::apache::thrift::required_field_ref parts_ref() const& { + return ::apache::thrift::required_field_ref{this->parts}; + } + + template > + FOLLY_ERASE ::apache::thrift::required_field_ref parts_ref() const&& { + return ::apache::thrift::required_field_ref{std::move(this->parts)}; + } + + template > + FOLLY_ERASE ::apache::thrift::required_field_ref parts_ref() & { + return ::apache::thrift::required_field_ref{this->parts}; + } + + template > + FOLLY_ERASE ::apache::thrift::required_field_ref parts_ref() && { + return ::apache::thrift::required_field_ref{std::move(this->parts)}; + } + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref indices_ref() const& { + return {this->indices, __isset.indices}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref indices_ref() const&& { + return {std::move(this->indices), __isset.indices}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref indices_ref() & { + return {this->indices, __isset.indices}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref indices_ref() && { + return {std::move(this->indices), __isset.indices}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::optional_field_ref return_columns_ref() const& { + return {this->return_columns, __isset.return_columns}; + } + + template > + FOLLY_ERASE ::apache::thrift::optional_field_ref return_columns_ref() const&& { + return {std::move(this->return_columns), __isset.return_columns}; + } + + template > + FOLLY_ERASE ::apache::thrift::optional_field_ref return_columns_ref() & { + return {this->return_columns, __isset.return_columns}; + } + + template > + FOLLY_ERASE ::apache::thrift::optional_field_ref return_columns_ref() && { + return {std::move(this->return_columns), __isset.return_columns}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::optional_field_ref common_ref() const& { + return {this->common, __isset.common}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref common_ref() const&& { + return {std::move(this->common), __isset.common}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref common_ref() & { + return {this->common, __isset.common}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref common_ref() && { + return {std::move(this->common), __isset.common}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::optional_field_ref limit_ref() const& { + return {this->limit, __isset.limit}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref limit_ref() const&& { + return {std::move(this->limit), __isset.limit}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref limit_ref() & { + return {this->limit, __isset.limit}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref limit_ref() && { + return {std::move(this->limit), __isset.limit}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::GraphSpaceID get_space_id() const { + return space_id; + } + + ::nebula::cpp2::GraphSpaceID& set_space_id( ::nebula::cpp2::GraphSpaceID space_id_) { + space_id = space_id_; + return space_id; + } + const ::std::vector< ::nebula::cpp2::PartitionID>& get_parts() const&; + ::std::vector< ::nebula::cpp2::PartitionID> get_parts() &&; + + template > + ::std::vector< ::nebula::cpp2::PartitionID>& set_parts(T_LookupIndexRequest_parts_struct_setter&& parts_) { + parts = std::forward(parts_); + return parts; + } + const ::nebula::storage::cpp2::IndexSpec& get_indices() const&; + ::nebula::storage::cpp2::IndexSpec get_indices() &&; + + template + ::nebula::storage::cpp2::IndexSpec& set_indices(T_LookupIndexRequest_indices_struct_setter&& indices_) { + indices = std::forward(indices_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.indices = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return indices; + } + const ::std::vector<::std::string>* get_return_columns() const&; + ::std::vector<::std::string>* get_return_columns() &; + ::std::vector<::std::string>* get_return_columns() && = delete; + + template > + ::std::vector<::std::string>& set_return_columns(T_LookupIndexRequest_return_columns_struct_setter&& return_columns_) { + return_columns = std::forward(return_columns_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.return_columns = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return return_columns; + } + const ::nebula::storage::cpp2::RequestCommon* get_common() const&; + ::nebula::storage::cpp2::RequestCommon* get_common() &; + ::nebula::storage::cpp2::RequestCommon* get_common() && = delete; + + template + ::nebula::storage::cpp2::RequestCommon& set_common(T_LookupIndexRequest_common_struct_setter&& common_) { + common = std::forward(common_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.common = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return common; + } + + const int64_t* get_limit() const& { + return limit_ref() ? std::addressof(limit) : nullptr; + } + + int64_t* get_limit() & { + return limit_ref() ? std::addressof(limit) : nullptr; + } + int64_t* get_limit() && = delete; + + int64_t& set_limit(int64_t limit_) { + limit = limit_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.limit = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return limit; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< LookupIndexRequest >; + friend void swap(LookupIndexRequest& a, LookupIndexRequest& b); +}; + +template +uint32_t LookupIndexRequest::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { +class LookupAndTraverseRequest final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = LookupAndTraverseRequest; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + + LookupAndTraverseRequest(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + LookupAndTraverseRequest(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, ::std::vector< ::nebula::cpp2::PartitionID> parts__arg, ::nebula::storage::cpp2::IndexSpec indices__arg, ::nebula::storage::cpp2::TraverseSpec traverse_spec__arg, ::nebula::storage::cpp2::RequestCommon common__arg); + + LookupAndTraverseRequest(LookupAndTraverseRequest&&) = default; + + LookupAndTraverseRequest(const LookupAndTraverseRequest&) = default; + + + LookupAndTraverseRequest& operator=(LookupAndTraverseRequest&&) = default; + + LookupAndTraverseRequest& operator=(const LookupAndTraverseRequest&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + + ~LookupAndTraverseRequest(); + + public: + ::nebula::cpp2::GraphSpaceID space_id; + public: + ::std::vector< ::nebula::cpp2::PartitionID> parts; + private: + ::nebula::storage::cpp2::IndexSpec indices; + private: + ::nebula::storage::cpp2::TraverseSpec traverse_spec; + private: + ::nebula::storage::cpp2::RequestCommon common; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool indices; + bool traverse_spec; + bool common; + } __isset = {}; + bool operator==(const LookupAndTraverseRequest& rhs) const; +#ifndef SWIG + friend bool operator!=(const LookupAndTraverseRequest& __x, const LookupAndTraverseRequest& __y) { + return !(__x == __y); + } +#endif + bool operator<(const LookupAndTraverseRequest& rhs) const; +#ifndef SWIG + friend bool operator>(const LookupAndTraverseRequest& __x, const LookupAndTraverseRequest& __y) { + return __y < __x; + } + friend bool operator<=(const LookupAndTraverseRequest& __x, const LookupAndTraverseRequest& __y) { + return !(__y < __x); + } + friend bool operator>=(const LookupAndTraverseRequest& __x, const LookupAndTraverseRequest& __y) { + return !(__x < __y); + } +#endif + template + FOLLY_ERASE ::apache::thrift::required_field_ref space_id_ref() const& { + return ::apache::thrift::required_field_ref{this->space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref space_id_ref() const&& { + return ::apache::thrift::required_field_ref{std::move(this->space_id)}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref space_id_ref() & { + return ::apache::thrift::required_field_ref{this->space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref space_id_ref() && { + return ::apache::thrift::required_field_ref{std::move(this->space_id)}; + } + template > + FOLLY_ERASE ::apache::thrift::required_field_ref parts_ref() const& { + return ::apache::thrift::required_field_ref{this->parts}; + } + + template > + FOLLY_ERASE ::apache::thrift::required_field_ref parts_ref() const&& { + return ::apache::thrift::required_field_ref{std::move(this->parts)}; + } + + template > + FOLLY_ERASE ::apache::thrift::required_field_ref parts_ref() & { + return ::apache::thrift::required_field_ref{this->parts}; + } + + template > + FOLLY_ERASE ::apache::thrift::required_field_ref parts_ref() && { + return ::apache::thrift::required_field_ref{std::move(this->parts)}; + } + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref indices_ref() const& { + return {this->indices, __isset.indices}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref indices_ref() const&& { + return {std::move(this->indices), __isset.indices}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref indices_ref() & { + return {this->indices, __isset.indices}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref indices_ref() && { + return {std::move(this->indices), __isset.indices}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref traverse_spec_ref() const& { + return {this->traverse_spec, __isset.traverse_spec}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref traverse_spec_ref() const&& { + return {std::move(this->traverse_spec), __isset.traverse_spec}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref traverse_spec_ref() & { + return {this->traverse_spec, __isset.traverse_spec}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref traverse_spec_ref() && { + return {std::move(this->traverse_spec), __isset.traverse_spec}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::optional_field_ref common_ref() const& { + return {this->common, __isset.common}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref common_ref() const&& { + return {std::move(this->common), __isset.common}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref common_ref() & { + return {this->common, __isset.common}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref common_ref() && { + return {std::move(this->common), __isset.common}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::GraphSpaceID get_space_id() const { + return space_id; + } + + ::nebula::cpp2::GraphSpaceID& set_space_id( ::nebula::cpp2::GraphSpaceID space_id_) { + space_id = space_id_; + return space_id; + } + const ::std::vector< ::nebula::cpp2::PartitionID>& get_parts() const&; + ::std::vector< ::nebula::cpp2::PartitionID> get_parts() &&; + + template > + ::std::vector< ::nebula::cpp2::PartitionID>& set_parts(T_LookupAndTraverseRequest_parts_struct_setter&& parts_) { + parts = std::forward(parts_); + return parts; + } + const ::nebula::storage::cpp2::IndexSpec& get_indices() const&; + ::nebula::storage::cpp2::IndexSpec get_indices() &&; + + template + ::nebula::storage::cpp2::IndexSpec& set_indices(T_LookupAndTraverseRequest_indices_struct_setter&& indices_) { + indices = std::forward(indices_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.indices = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return indices; + } + const ::nebula::storage::cpp2::TraverseSpec& get_traverse_spec() const&; + ::nebula::storage::cpp2::TraverseSpec get_traverse_spec() &&; + + template + ::nebula::storage::cpp2::TraverseSpec& set_traverse_spec(T_LookupAndTraverseRequest_traverse_spec_struct_setter&& traverse_spec_) { + traverse_spec = std::forward(traverse_spec_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.traverse_spec = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return traverse_spec; + } + const ::nebula::storage::cpp2::RequestCommon* get_common() const&; + ::nebula::storage::cpp2::RequestCommon* get_common() &; + ::nebula::storage::cpp2::RequestCommon* get_common() && = delete; + + template + ::nebula::storage::cpp2::RequestCommon& set_common(T_LookupAndTraverseRequest_common_struct_setter&& common_) { + common = std::forward(common_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.common = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return common; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< LookupAndTraverseRequest >; + friend void swap(LookupAndTraverseRequest& a, LookupAndTraverseRequest& b); +}; + +template +uint32_t LookupAndTraverseRequest::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { +class ScanVertexRequest final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = ScanVertexRequest; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + + ScanVertexRequest(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + ScanVertexRequest(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, ::nebula::cpp2::PartitionID part_id__arg, ::std::string cursor__arg, ::nebula::storage::cpp2::VertexProp return_columns__arg, int64_t limit__arg, int64_t start_time__arg, int64_t end_time__arg, ::std::string filter__arg, bool only_latest_version__arg, bool enable_read_from_follower__arg, ::nebula::storage::cpp2::RequestCommon common__arg); + + ScanVertexRequest(ScanVertexRequest&&) = default; + + ScanVertexRequest(const ScanVertexRequest&) = default; + + + ScanVertexRequest& operator=(ScanVertexRequest&&) = default; + + ScanVertexRequest& operator=(const ScanVertexRequest&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + + ~ScanVertexRequest(); + + private: + ::nebula::cpp2::GraphSpaceID space_id; + private: + ::nebula::cpp2::PartitionID part_id; + private: + ::std::string cursor; + private: + ::nebula::storage::cpp2::VertexProp return_columns; + private: + int64_t limit; + private: + int64_t start_time; + private: + int64_t end_time; + private: + ::std::string filter; + private: + bool only_latest_version; + private: + bool enable_read_from_follower; + private: + ::nebula::storage::cpp2::RequestCommon common; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool space_id; + bool part_id; + bool cursor; + bool return_columns; + bool limit; + bool start_time; + bool end_time; + bool filter; + bool only_latest_version; + bool enable_read_from_follower; + bool common; + } __isset = {}; + bool operator==(const ScanVertexRequest& rhs) const; +#ifndef SWIG + friend bool operator!=(const ScanVertexRequest& __x, const ScanVertexRequest& __y) { + return !(__x == __y); + } +#endif + bool operator<(const ScanVertexRequest& rhs) const; +#ifndef SWIG + friend bool operator>(const ScanVertexRequest& __x, const ScanVertexRequest& __y) { + return __y < __x; + } + friend bool operator<=(const ScanVertexRequest& __x, const ScanVertexRequest& __y) { + return !(__y < __x); + } + friend bool operator>=(const ScanVertexRequest& __x, const ScanVertexRequest& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const& { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const&& { + return {std::move(this->space_id), __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() & { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() && { + return {std::move(this->space_id), __isset.space_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref part_id_ref() const& { + return {this->part_id, __isset.part_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref part_id_ref() const&& { + return {std::move(this->part_id), __isset.part_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref part_id_ref() & { + return {this->part_id, __isset.part_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref part_id_ref() && { + return {std::move(this->part_id), __isset.part_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::optional_field_ref cursor_ref() const& { + return {this->cursor, __isset.cursor}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref cursor_ref() const&& { + return {std::move(this->cursor), __isset.cursor}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref cursor_ref() & { + return {this->cursor, __isset.cursor}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref cursor_ref() && { + return {std::move(this->cursor), __isset.cursor}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref return_columns_ref() const& { + return {this->return_columns, __isset.return_columns}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref return_columns_ref() const&& { + return {std::move(this->return_columns), __isset.return_columns}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref return_columns_ref() & { + return {this->return_columns, __isset.return_columns}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref return_columns_ref() && { + return {std::move(this->return_columns), __isset.return_columns}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref limit_ref() const& { + return {this->limit, __isset.limit}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref limit_ref() const&& { + return {std::move(this->limit), __isset.limit}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref limit_ref() & { + return {this->limit, __isset.limit}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref limit_ref() && { + return {std::move(this->limit), __isset.limit}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::optional_field_ref start_time_ref() const& { + return {this->start_time, __isset.start_time}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref start_time_ref() const&& { + return {std::move(this->start_time), __isset.start_time}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref start_time_ref() & { + return {this->start_time, __isset.start_time}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref start_time_ref() && { + return {std::move(this->start_time), __isset.start_time}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::optional_field_ref end_time_ref() const& { + return {this->end_time, __isset.end_time}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref end_time_ref() const&& { + return {std::move(this->end_time), __isset.end_time}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref end_time_ref() & { + return {this->end_time, __isset.end_time}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref end_time_ref() && { + return {std::move(this->end_time), __isset.end_time}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::optional_field_ref filter_ref() const& { + return {this->filter, __isset.filter}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref filter_ref() const&& { + return {std::move(this->filter), __isset.filter}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref filter_ref() & { + return {this->filter, __isset.filter}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref filter_ref() && { + return {std::move(this->filter), __isset.filter}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref only_latest_version_ref() const& { + return {this->only_latest_version, __isset.only_latest_version}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref only_latest_version_ref() const&& { + return {std::move(this->only_latest_version), __isset.only_latest_version}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref only_latest_version_ref() & { + return {this->only_latest_version, __isset.only_latest_version}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref only_latest_version_ref() && { + return {std::move(this->only_latest_version), __isset.only_latest_version}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref enable_read_from_follower_ref() const& { + return {this->enable_read_from_follower, __isset.enable_read_from_follower}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref enable_read_from_follower_ref() const&& { + return {std::move(this->enable_read_from_follower), __isset.enable_read_from_follower}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref enable_read_from_follower_ref() & { + return {this->enable_read_from_follower, __isset.enable_read_from_follower}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref enable_read_from_follower_ref() && { + return {std::move(this->enable_read_from_follower), __isset.enable_read_from_follower}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::optional_field_ref common_ref() const& { + return {this->common, __isset.common}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref common_ref() const&& { + return {std::move(this->common), __isset.common}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref common_ref() & { + return {this->common, __isset.common}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref common_ref() && { + return {std::move(this->common), __isset.common}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::GraphSpaceID get_space_id() const { + return space_id; + } + + ::nebula::cpp2::GraphSpaceID& set_space_id( ::nebula::cpp2::GraphSpaceID space_id_) { + space_id = space_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.space_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return space_id; + } + + ::nebula::cpp2::PartitionID get_part_id() const { + return part_id; + } + + ::nebula::cpp2::PartitionID& set_part_id( ::nebula::cpp2::PartitionID part_id_) { + part_id = part_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.part_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return part_id; + } + + const ::std::string* get_cursor() const& { + return cursor_ref() ? std::addressof(cursor) : nullptr; + } + + ::std::string* get_cursor() & { + return cursor_ref() ? std::addressof(cursor) : nullptr; + } + ::std::string* get_cursor() && = delete; + + template + ::std::string& set_cursor(T_ScanVertexRequest_cursor_struct_setter&& cursor_) { + cursor = std::forward(cursor_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.cursor = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return cursor; + } + const ::nebula::storage::cpp2::VertexProp& get_return_columns() const&; + ::nebula::storage::cpp2::VertexProp get_return_columns() &&; + + template + ::nebula::storage::cpp2::VertexProp& set_return_columns(T_ScanVertexRequest_return_columns_struct_setter&& return_columns_) { + return_columns = std::forward(return_columns_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.return_columns = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return return_columns; + } + + int64_t get_limit() const { + return limit; + } + + int64_t& set_limit(int64_t limit_) { + limit = limit_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.limit = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return limit; + } + + const int64_t* get_start_time() const& { + return start_time_ref() ? std::addressof(start_time) : nullptr; + } + + int64_t* get_start_time() & { + return start_time_ref() ? std::addressof(start_time) : nullptr; + } + int64_t* get_start_time() && = delete; + + int64_t& set_start_time(int64_t start_time_) { + start_time = start_time_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.start_time = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return start_time; + } + + const int64_t* get_end_time() const& { + return end_time_ref() ? std::addressof(end_time) : nullptr; + } + + int64_t* get_end_time() & { + return end_time_ref() ? std::addressof(end_time) : nullptr; + } + int64_t* get_end_time() && = delete; + + int64_t& set_end_time(int64_t end_time_) { + end_time = end_time_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.end_time = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return end_time; + } + + const ::std::string* get_filter() const& { + return filter_ref() ? std::addressof(filter) : nullptr; + } + + ::std::string* get_filter() & { + return filter_ref() ? std::addressof(filter) : nullptr; + } + ::std::string* get_filter() && = delete; + + template + ::std::string& set_filter(T_ScanVertexRequest_filter_struct_setter&& filter_) { + filter = std::forward(filter_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.filter = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return filter; + } + + bool get_only_latest_version() const { + return only_latest_version; + } + + bool& set_only_latest_version(bool only_latest_version_) { + only_latest_version = only_latest_version_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.only_latest_version = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return only_latest_version; + } + + bool get_enable_read_from_follower() const { + return enable_read_from_follower; + } + + bool& set_enable_read_from_follower(bool enable_read_from_follower_) { + enable_read_from_follower = enable_read_from_follower_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.enable_read_from_follower = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return enable_read_from_follower; + } + const ::nebula::storage::cpp2::RequestCommon* get_common() const&; + ::nebula::storage::cpp2::RequestCommon* get_common() &; + ::nebula::storage::cpp2::RequestCommon* get_common() && = delete; + + template + ::nebula::storage::cpp2::RequestCommon& set_common(T_ScanVertexRequest_common_struct_setter&& common_) { + common = std::forward(common_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.common = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return common; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< ScanVertexRequest >; + friend void swap(ScanVertexRequest& a, ScanVertexRequest& b); +}; + +template +uint32_t ScanVertexRequest::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { +class ScanVertexResponse final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = ScanVertexResponse; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + ScanVertexResponse() : + has_next(0) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + ScanVertexResponse(apache::thrift::FragileConstructor, ::nebula::storage::cpp2::ResponseCommon result__arg, nebula::DataSet vertex_data__arg, bool has_next__arg, ::std::string next_cursor__arg); + + ScanVertexResponse(ScanVertexResponse&&) = default; + + ScanVertexResponse(const ScanVertexResponse&) = default; + + + ScanVertexResponse& operator=(ScanVertexResponse&&) = default; + + ScanVertexResponse& operator=(const ScanVertexResponse&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + public: + ::nebula::storage::cpp2::ResponseCommon result; + private: + nebula::DataSet vertex_data; + private: + bool has_next; + private: + ::std::string next_cursor; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool vertex_data; + bool has_next; + bool next_cursor; + } __isset = {}; + bool operator==(const ScanVertexResponse& rhs) const; +#ifndef SWIG + friend bool operator!=(const ScanVertexResponse& __x, const ScanVertexResponse& __y) { + return !(__x == __y); + } +#endif + bool operator<(const ScanVertexResponse& rhs) const; +#ifndef SWIG + friend bool operator>(const ScanVertexResponse& __x, const ScanVertexResponse& __y) { + return __y < __x; + } + friend bool operator<=(const ScanVertexResponse& __x, const ScanVertexResponse& __y) { + return !(__y < __x); + } + friend bool operator>=(const ScanVertexResponse& __x, const ScanVertexResponse& __y) { + return !(__x < __y); + } +#endif + template + FOLLY_ERASE ::apache::thrift::required_field_ref result_ref() const& { + return ::apache::thrift::required_field_ref{this->result}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref result_ref() const&& { + return ::apache::thrift::required_field_ref{std::move(this->result)}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref result_ref() & { + return ::apache::thrift::required_field_ref{this->result}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref result_ref() && { + return ::apache::thrift::required_field_ref{std::move(this->result)}; + } + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref vertex_data_ref() const& { + return {this->vertex_data, __isset.vertex_data}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref vertex_data_ref() const&& { + return {std::move(this->vertex_data), __isset.vertex_data}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref vertex_data_ref() & { + return {this->vertex_data, __isset.vertex_data}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref vertex_data_ref() && { + return {std::move(this->vertex_data), __isset.vertex_data}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref has_next_ref() const& { + return {this->has_next, __isset.has_next}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref has_next_ref() const&& { + return {std::move(this->has_next), __isset.has_next}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref has_next_ref() & { + return {this->has_next, __isset.has_next}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref has_next_ref() && { + return {std::move(this->has_next), __isset.has_next}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::optional_field_ref next_cursor_ref() const& { + return {this->next_cursor, __isset.next_cursor}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref next_cursor_ref() const&& { + return {std::move(this->next_cursor), __isset.next_cursor}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref next_cursor_ref() & { + return {this->next_cursor, __isset.next_cursor}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref next_cursor_ref() && { + return {std::move(this->next_cursor), __isset.next_cursor}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + const ::nebula::storage::cpp2::ResponseCommon& get_result() const&; + ::nebula::storage::cpp2::ResponseCommon get_result() &&; + + template + ::nebula::storage::cpp2::ResponseCommon& set_result(T_ScanVertexResponse_result_struct_setter&& result_) { + result = std::forward(result_); + return result; + } + const nebula::DataSet& get_vertex_data() const&; + nebula::DataSet get_vertex_data() &&; + + template + nebula::DataSet& set_vertex_data(T_ScanVertexResponse_vertex_data_struct_setter&& vertex_data_) { + vertex_data = std::forward(vertex_data_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.vertex_data = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return vertex_data; + } + + bool get_has_next() const { + return has_next; + } + + bool& set_has_next(bool has_next_) { + has_next = has_next_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.has_next = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return has_next; + } + + const ::std::string* get_next_cursor() const& { + return next_cursor_ref() ? std::addressof(next_cursor) : nullptr; + } + + ::std::string* get_next_cursor() & { + return next_cursor_ref() ? std::addressof(next_cursor) : nullptr; + } + ::std::string* get_next_cursor() && = delete; + + template + ::std::string& set_next_cursor(T_ScanVertexResponse_next_cursor_struct_setter&& next_cursor_) { + next_cursor = std::forward(next_cursor_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.next_cursor = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return next_cursor; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< ScanVertexResponse >; + friend void swap(ScanVertexResponse& a, ScanVertexResponse& b); +}; + +template +uint32_t ScanVertexResponse::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { +class ScanEdgeRequest final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = ScanEdgeRequest; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + + ScanEdgeRequest(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + ScanEdgeRequest(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, ::nebula::cpp2::PartitionID part_id__arg, ::std::string cursor__arg, ::nebula::storage::cpp2::EdgeProp return_columns__arg, int64_t limit__arg, int64_t start_time__arg, int64_t end_time__arg, ::std::string filter__arg, bool only_latest_version__arg, bool enable_read_from_follower__arg, ::nebula::storage::cpp2::RequestCommon common__arg); + + ScanEdgeRequest(ScanEdgeRequest&&) = default; + + ScanEdgeRequest(const ScanEdgeRequest&) = default; + + + ScanEdgeRequest& operator=(ScanEdgeRequest&&) = default; + + ScanEdgeRequest& operator=(const ScanEdgeRequest&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + + ~ScanEdgeRequest(); + + private: + ::nebula::cpp2::GraphSpaceID space_id; + private: + ::nebula::cpp2::PartitionID part_id; + private: + ::std::string cursor; + private: + ::nebula::storage::cpp2::EdgeProp return_columns; + private: + int64_t limit; + private: + int64_t start_time; + private: + int64_t end_time; + private: + ::std::string filter; + private: + bool only_latest_version; + private: + bool enable_read_from_follower; + private: + ::nebula::storage::cpp2::RequestCommon common; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool space_id; + bool part_id; + bool cursor; + bool return_columns; + bool limit; + bool start_time; + bool end_time; + bool filter; + bool only_latest_version; + bool enable_read_from_follower; + bool common; + } __isset = {}; + bool operator==(const ScanEdgeRequest& rhs) const; +#ifndef SWIG + friend bool operator!=(const ScanEdgeRequest& __x, const ScanEdgeRequest& __y) { + return !(__x == __y); + } +#endif + bool operator<(const ScanEdgeRequest& rhs) const; +#ifndef SWIG + friend bool operator>(const ScanEdgeRequest& __x, const ScanEdgeRequest& __y) { + return __y < __x; + } + friend bool operator<=(const ScanEdgeRequest& __x, const ScanEdgeRequest& __y) { + return !(__y < __x); + } + friend bool operator>=(const ScanEdgeRequest& __x, const ScanEdgeRequest& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const& { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const&& { + return {std::move(this->space_id), __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() & { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() && { + return {std::move(this->space_id), __isset.space_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref part_id_ref() const& { + return {this->part_id, __isset.part_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref part_id_ref() const&& { + return {std::move(this->part_id), __isset.part_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref part_id_ref() & { + return {this->part_id, __isset.part_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref part_id_ref() && { + return {std::move(this->part_id), __isset.part_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::optional_field_ref cursor_ref() const& { + return {this->cursor, __isset.cursor}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref cursor_ref() const&& { + return {std::move(this->cursor), __isset.cursor}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref cursor_ref() & { + return {this->cursor, __isset.cursor}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref cursor_ref() && { + return {std::move(this->cursor), __isset.cursor}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref return_columns_ref() const& { + return {this->return_columns, __isset.return_columns}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref return_columns_ref() const&& { + return {std::move(this->return_columns), __isset.return_columns}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref return_columns_ref() & { + return {this->return_columns, __isset.return_columns}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref return_columns_ref() && { + return {std::move(this->return_columns), __isset.return_columns}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref limit_ref() const& { + return {this->limit, __isset.limit}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref limit_ref() const&& { + return {std::move(this->limit), __isset.limit}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref limit_ref() & { + return {this->limit, __isset.limit}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref limit_ref() && { + return {std::move(this->limit), __isset.limit}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::optional_field_ref start_time_ref() const& { + return {this->start_time, __isset.start_time}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref start_time_ref() const&& { + return {std::move(this->start_time), __isset.start_time}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref start_time_ref() & { + return {this->start_time, __isset.start_time}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref start_time_ref() && { + return {std::move(this->start_time), __isset.start_time}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::optional_field_ref end_time_ref() const& { + return {this->end_time, __isset.end_time}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref end_time_ref() const&& { + return {std::move(this->end_time), __isset.end_time}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref end_time_ref() & { + return {this->end_time, __isset.end_time}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref end_time_ref() && { + return {std::move(this->end_time), __isset.end_time}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::optional_field_ref filter_ref() const& { + return {this->filter, __isset.filter}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref filter_ref() const&& { + return {std::move(this->filter), __isset.filter}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref filter_ref() & { + return {this->filter, __isset.filter}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref filter_ref() && { + return {std::move(this->filter), __isset.filter}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref only_latest_version_ref() const& { + return {this->only_latest_version, __isset.only_latest_version}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref only_latest_version_ref() const&& { + return {std::move(this->only_latest_version), __isset.only_latest_version}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref only_latest_version_ref() & { + return {this->only_latest_version, __isset.only_latest_version}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref only_latest_version_ref() && { + return {std::move(this->only_latest_version), __isset.only_latest_version}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref enable_read_from_follower_ref() const& { + return {this->enable_read_from_follower, __isset.enable_read_from_follower}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref enable_read_from_follower_ref() const&& { + return {std::move(this->enable_read_from_follower), __isset.enable_read_from_follower}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref enable_read_from_follower_ref() & { + return {this->enable_read_from_follower, __isset.enable_read_from_follower}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref enable_read_from_follower_ref() && { + return {std::move(this->enable_read_from_follower), __isset.enable_read_from_follower}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::optional_field_ref common_ref() const& { + return {this->common, __isset.common}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref common_ref() const&& { + return {std::move(this->common), __isset.common}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref common_ref() & { + return {this->common, __isset.common}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref common_ref() && { + return {std::move(this->common), __isset.common}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::GraphSpaceID get_space_id() const { + return space_id; + } + + ::nebula::cpp2::GraphSpaceID& set_space_id( ::nebula::cpp2::GraphSpaceID space_id_) { + space_id = space_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.space_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return space_id; + } + + ::nebula::cpp2::PartitionID get_part_id() const { + return part_id; + } + + ::nebula::cpp2::PartitionID& set_part_id( ::nebula::cpp2::PartitionID part_id_) { + part_id = part_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.part_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return part_id; + } + + const ::std::string* get_cursor() const& { + return cursor_ref() ? std::addressof(cursor) : nullptr; + } + + ::std::string* get_cursor() & { + return cursor_ref() ? std::addressof(cursor) : nullptr; + } + ::std::string* get_cursor() && = delete; + + template + ::std::string& set_cursor(T_ScanEdgeRequest_cursor_struct_setter&& cursor_) { + cursor = std::forward(cursor_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.cursor = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return cursor; + } + const ::nebula::storage::cpp2::EdgeProp& get_return_columns() const&; + ::nebula::storage::cpp2::EdgeProp get_return_columns() &&; + + template + ::nebula::storage::cpp2::EdgeProp& set_return_columns(T_ScanEdgeRequest_return_columns_struct_setter&& return_columns_) { + return_columns = std::forward(return_columns_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.return_columns = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return return_columns; + } + + int64_t get_limit() const { + return limit; + } + + int64_t& set_limit(int64_t limit_) { + limit = limit_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.limit = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return limit; + } + + const int64_t* get_start_time() const& { + return start_time_ref() ? std::addressof(start_time) : nullptr; + } + + int64_t* get_start_time() & { + return start_time_ref() ? std::addressof(start_time) : nullptr; + } + int64_t* get_start_time() && = delete; + + int64_t& set_start_time(int64_t start_time_) { + start_time = start_time_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.start_time = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return start_time; + } + + const int64_t* get_end_time() const& { + return end_time_ref() ? std::addressof(end_time) : nullptr; + } + + int64_t* get_end_time() & { + return end_time_ref() ? std::addressof(end_time) : nullptr; + } + int64_t* get_end_time() && = delete; + + int64_t& set_end_time(int64_t end_time_) { + end_time = end_time_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.end_time = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return end_time; + } + + const ::std::string* get_filter() const& { + return filter_ref() ? std::addressof(filter) : nullptr; + } + + ::std::string* get_filter() & { + return filter_ref() ? std::addressof(filter) : nullptr; + } + ::std::string* get_filter() && = delete; + + template + ::std::string& set_filter(T_ScanEdgeRequest_filter_struct_setter&& filter_) { + filter = std::forward(filter_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.filter = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return filter; + } + + bool get_only_latest_version() const { + return only_latest_version; + } + + bool& set_only_latest_version(bool only_latest_version_) { + only_latest_version = only_latest_version_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.only_latest_version = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return only_latest_version; + } + + bool get_enable_read_from_follower() const { + return enable_read_from_follower; + } + + bool& set_enable_read_from_follower(bool enable_read_from_follower_) { + enable_read_from_follower = enable_read_from_follower_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.enable_read_from_follower = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return enable_read_from_follower; + } + const ::nebula::storage::cpp2::RequestCommon* get_common() const&; + ::nebula::storage::cpp2::RequestCommon* get_common() &; + ::nebula::storage::cpp2::RequestCommon* get_common() && = delete; + + template + ::nebula::storage::cpp2::RequestCommon& set_common(T_ScanEdgeRequest_common_struct_setter&& common_) { + common = std::forward(common_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.common = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return common; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< ScanEdgeRequest >; + friend void swap(ScanEdgeRequest& a, ScanEdgeRequest& b); +}; + +template +uint32_t ScanEdgeRequest::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { +class ScanEdgeResponse final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = ScanEdgeResponse; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + ScanEdgeResponse() : + has_next(0) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + ScanEdgeResponse(apache::thrift::FragileConstructor, ::nebula::storage::cpp2::ResponseCommon result__arg, nebula::DataSet edge_data__arg, bool has_next__arg, ::std::string next_cursor__arg); + + ScanEdgeResponse(ScanEdgeResponse&&) = default; + + ScanEdgeResponse(const ScanEdgeResponse&) = default; + + + ScanEdgeResponse& operator=(ScanEdgeResponse&&) = default; + + ScanEdgeResponse& operator=(const ScanEdgeResponse&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + public: + ::nebula::storage::cpp2::ResponseCommon result; + private: + nebula::DataSet edge_data; + private: + bool has_next; + private: + ::std::string next_cursor; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool edge_data; + bool has_next; + bool next_cursor; + } __isset = {}; + bool operator==(const ScanEdgeResponse& rhs) const; +#ifndef SWIG + friend bool operator!=(const ScanEdgeResponse& __x, const ScanEdgeResponse& __y) { + return !(__x == __y); + } +#endif + bool operator<(const ScanEdgeResponse& rhs) const; +#ifndef SWIG + friend bool operator>(const ScanEdgeResponse& __x, const ScanEdgeResponse& __y) { + return __y < __x; + } + friend bool operator<=(const ScanEdgeResponse& __x, const ScanEdgeResponse& __y) { + return !(__y < __x); + } + friend bool operator>=(const ScanEdgeResponse& __x, const ScanEdgeResponse& __y) { + return !(__x < __y); + } +#endif + template + FOLLY_ERASE ::apache::thrift::required_field_ref result_ref() const& { + return ::apache::thrift::required_field_ref{this->result}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref result_ref() const&& { + return ::apache::thrift::required_field_ref{std::move(this->result)}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref result_ref() & { + return ::apache::thrift::required_field_ref{this->result}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref result_ref() && { + return ::apache::thrift::required_field_ref{std::move(this->result)}; + } + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref edge_data_ref() const& { + return {this->edge_data, __isset.edge_data}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref edge_data_ref() const&& { + return {std::move(this->edge_data), __isset.edge_data}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref edge_data_ref() & { + return {this->edge_data, __isset.edge_data}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref edge_data_ref() && { + return {std::move(this->edge_data), __isset.edge_data}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref has_next_ref() const& { + return {this->has_next, __isset.has_next}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref has_next_ref() const&& { + return {std::move(this->has_next), __isset.has_next}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref has_next_ref() & { + return {this->has_next, __isset.has_next}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref has_next_ref() && { + return {std::move(this->has_next), __isset.has_next}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::optional_field_ref next_cursor_ref() const& { + return {this->next_cursor, __isset.next_cursor}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref next_cursor_ref() const&& { + return {std::move(this->next_cursor), __isset.next_cursor}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref next_cursor_ref() & { + return {this->next_cursor, __isset.next_cursor}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref next_cursor_ref() && { + return {std::move(this->next_cursor), __isset.next_cursor}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + const ::nebula::storage::cpp2::ResponseCommon& get_result() const&; + ::nebula::storage::cpp2::ResponseCommon get_result() &&; + + template + ::nebula::storage::cpp2::ResponseCommon& set_result(T_ScanEdgeResponse_result_struct_setter&& result_) { + result = std::forward(result_); + return result; + } + const nebula::DataSet& get_edge_data() const&; + nebula::DataSet get_edge_data() &&; + + template + nebula::DataSet& set_edge_data(T_ScanEdgeResponse_edge_data_struct_setter&& edge_data_) { + edge_data = std::forward(edge_data_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.edge_data = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return edge_data; + } + + bool get_has_next() const { + return has_next; + } + + bool& set_has_next(bool has_next_) { + has_next = has_next_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.has_next = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return has_next; + } + + const ::std::string* get_next_cursor() const& { + return next_cursor_ref() ? std::addressof(next_cursor) : nullptr; + } + + ::std::string* get_next_cursor() & { + return next_cursor_ref() ? std::addressof(next_cursor) : nullptr; + } + ::std::string* get_next_cursor() && = delete; + + template + ::std::string& set_next_cursor(T_ScanEdgeResponse_next_cursor_struct_setter&& next_cursor_) { + next_cursor = std::forward(next_cursor_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.next_cursor = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return next_cursor; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< ScanEdgeResponse >; + friend void swap(ScanEdgeResponse& a, ScanEdgeResponse& b); +}; + +template +uint32_t ScanEdgeResponse::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { +class TaskPara final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = TaskPara; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + TaskPara() : + space_id(0) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + TaskPara(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, ::std::vector< ::nebula::cpp2::PartitionID> parts__arg, ::std::vector<::std::string> task_specfic_paras__arg); + + TaskPara(TaskPara&&) = default; + + TaskPara(const TaskPara&) = default; + + + TaskPara& operator=(TaskPara&&) = default; + + TaskPara& operator=(const TaskPara&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::GraphSpaceID space_id; + private: + ::std::vector< ::nebula::cpp2::PartitionID> parts; + private: + ::std::vector<::std::string> task_specfic_paras; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool space_id; + bool parts; + bool task_specfic_paras; + } __isset = {}; + bool operator==(const TaskPara& rhs) const; +#ifndef SWIG + friend bool operator!=(const TaskPara& __x, const TaskPara& __y) { + return !(__x == __y); + } +#endif + bool operator<(const TaskPara& rhs) const; +#ifndef SWIG + friend bool operator>(const TaskPara& __x, const TaskPara& __y) { + return __y < __x; + } + friend bool operator<=(const TaskPara& __x, const TaskPara& __y) { + return !(__y < __x); + } + friend bool operator>=(const TaskPara& __x, const TaskPara& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const& { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const&& { + return {std::move(this->space_id), __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() & { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() && { + return {std::move(this->space_id), __isset.space_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::optional_field_ref parts_ref() const& { + return {this->parts, __isset.parts}; + } + + template > + FOLLY_ERASE ::apache::thrift::optional_field_ref parts_ref() const&& { + return {std::move(this->parts), __isset.parts}; + } + + template > + FOLLY_ERASE ::apache::thrift::optional_field_ref parts_ref() & { + return {this->parts, __isset.parts}; + } + + template > + FOLLY_ERASE ::apache::thrift::optional_field_ref parts_ref() && { + return {std::move(this->parts), __isset.parts}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::optional_field_ref task_specfic_paras_ref() const& { + return {this->task_specfic_paras, __isset.task_specfic_paras}; + } + + template > + FOLLY_ERASE ::apache::thrift::optional_field_ref task_specfic_paras_ref() const&& { + return {std::move(this->task_specfic_paras), __isset.task_specfic_paras}; + } + + template > + FOLLY_ERASE ::apache::thrift::optional_field_ref task_specfic_paras_ref() & { + return {this->task_specfic_paras, __isset.task_specfic_paras}; + } + + template > + FOLLY_ERASE ::apache::thrift::optional_field_ref task_specfic_paras_ref() && { + return {std::move(this->task_specfic_paras), __isset.task_specfic_paras}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::GraphSpaceID get_space_id() const { + return space_id; + } + + ::nebula::cpp2::GraphSpaceID& set_space_id( ::nebula::cpp2::GraphSpaceID space_id_) { + space_id = space_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.space_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return space_id; + } + const ::std::vector< ::nebula::cpp2::PartitionID>* get_parts() const&; + ::std::vector< ::nebula::cpp2::PartitionID>* get_parts() &; + ::std::vector< ::nebula::cpp2::PartitionID>* get_parts() && = delete; + + template > + ::std::vector< ::nebula::cpp2::PartitionID>& set_parts(T_TaskPara_parts_struct_setter&& parts_) { + parts = std::forward(parts_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.parts = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return parts; + } + const ::std::vector<::std::string>* get_task_specfic_paras() const&; + ::std::vector<::std::string>* get_task_specfic_paras() &; + ::std::vector<::std::string>* get_task_specfic_paras() && = delete; + + template > + ::std::vector<::std::string>& set_task_specfic_paras(T_TaskPara_task_specfic_paras_struct_setter&& task_specfic_paras_) { + task_specfic_paras = std::forward(task_specfic_paras_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.task_specfic_paras = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return task_specfic_paras; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< TaskPara >; + friend void swap(TaskPara& a, TaskPara& b); +}; + +template +uint32_t TaskPara::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { +class AddAdminTaskRequest final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = AddAdminTaskRequest; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + AddAdminTaskRequest() : + cmd( ::nebula::meta::cpp2::AdminCmd::COMPACT), + job_id(0), + task_id(0), + concurrency(0) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + AddAdminTaskRequest(apache::thrift::FragileConstructor, ::nebula::meta::cpp2::AdminCmd cmd__arg, int32_t job_id__arg, int32_t task_id__arg, ::nebula::storage::cpp2::TaskPara para__arg, int32_t concurrency__arg); + + AddAdminTaskRequest(AddAdminTaskRequest&&) = default; + + AddAdminTaskRequest(const AddAdminTaskRequest&) = default; + + + AddAdminTaskRequest& operator=(AddAdminTaskRequest&&) = default; + + AddAdminTaskRequest& operator=(const AddAdminTaskRequest&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::meta::cpp2::AdminCmd cmd; + private: + int32_t job_id; + private: + int32_t task_id; + private: + ::nebula::storage::cpp2::TaskPara para; + private: + int32_t concurrency; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool cmd; + bool job_id; + bool task_id; + bool para; + bool concurrency; + } __isset = {}; + bool operator==(const AddAdminTaskRequest& rhs) const; +#ifndef SWIG + friend bool operator!=(const AddAdminTaskRequest& __x, const AddAdminTaskRequest& __y) { + return !(__x == __y); + } +#endif + bool operator<(const AddAdminTaskRequest& rhs) const; +#ifndef SWIG + friend bool operator>(const AddAdminTaskRequest& __x, const AddAdminTaskRequest& __y) { + return __y < __x; + } + friend bool operator<=(const AddAdminTaskRequest& __x, const AddAdminTaskRequest& __y) { + return !(__y < __x); + } + friend bool operator>=(const AddAdminTaskRequest& __x, const AddAdminTaskRequest& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref cmd_ref() const& { + return {this->cmd, __isset.cmd}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref cmd_ref() const&& { + return {std::move(this->cmd), __isset.cmd}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref cmd_ref() & { + return {this->cmd, __isset.cmd}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref cmd_ref() && { + return {std::move(this->cmd), __isset.cmd}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref job_id_ref() const& { + return {this->job_id, __isset.job_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref job_id_ref() const&& { + return {std::move(this->job_id), __isset.job_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref job_id_ref() & { + return {this->job_id, __isset.job_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref job_id_ref() && { + return {std::move(this->job_id), __isset.job_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref task_id_ref() const& { + return {this->task_id, __isset.task_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref task_id_ref() const&& { + return {std::move(this->task_id), __isset.task_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref task_id_ref() & { + return {this->task_id, __isset.task_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref task_id_ref() && { + return {std::move(this->task_id), __isset.task_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref para_ref() const& { + return {this->para, __isset.para}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref para_ref() const&& { + return {std::move(this->para), __isset.para}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref para_ref() & { + return {this->para, __isset.para}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref para_ref() && { + return {std::move(this->para), __isset.para}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::optional_field_ref concurrency_ref() const& { + return {this->concurrency, __isset.concurrency}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref concurrency_ref() const&& { + return {std::move(this->concurrency), __isset.concurrency}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref concurrency_ref() & { + return {this->concurrency, __isset.concurrency}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref concurrency_ref() && { + return {std::move(this->concurrency), __isset.concurrency}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::meta::cpp2::AdminCmd get_cmd() const { + return cmd; + } + + ::nebula::meta::cpp2::AdminCmd& set_cmd( ::nebula::meta::cpp2::AdminCmd cmd_) { + cmd = cmd_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.cmd = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return cmd; + } + + int32_t get_job_id() const { + return job_id; + } + + int32_t& set_job_id(int32_t job_id_) { + job_id = job_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.job_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return job_id; + } + + int32_t get_task_id() const { + return task_id; + } + + int32_t& set_task_id(int32_t task_id_) { + task_id = task_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.task_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return task_id; + } + const ::nebula::storage::cpp2::TaskPara& get_para() const&; + ::nebula::storage::cpp2::TaskPara get_para() &&; + + template + ::nebula::storage::cpp2::TaskPara& set_para(T_AddAdminTaskRequest_para_struct_setter&& para_) { + para = std::forward(para_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.para = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return para; + } + + const int32_t* get_concurrency() const& { + return concurrency_ref() ? std::addressof(concurrency) : nullptr; + } + + int32_t* get_concurrency() & { + return concurrency_ref() ? std::addressof(concurrency) : nullptr; + } + int32_t* get_concurrency() && = delete; + + int32_t& set_concurrency(int32_t concurrency_) { + concurrency = concurrency_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.concurrency = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return concurrency; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< AddAdminTaskRequest >; + friend void swap(AddAdminTaskRequest& a, AddAdminTaskRequest& b); +}; + +template +uint32_t AddAdminTaskRequest::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { +class StopAdminTaskRequest final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = StopAdminTaskRequest; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + StopAdminTaskRequest() : + job_id(0), + task_id(0) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + StopAdminTaskRequest(apache::thrift::FragileConstructor, int32_t job_id__arg, int32_t task_id__arg); + + StopAdminTaskRequest(StopAdminTaskRequest&&) = default; + + StopAdminTaskRequest(const StopAdminTaskRequest&) = default; + + + StopAdminTaskRequest& operator=(StopAdminTaskRequest&&) = default; + + StopAdminTaskRequest& operator=(const StopAdminTaskRequest&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + int32_t job_id; + private: + int32_t task_id; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool job_id; + bool task_id; + } __isset = {}; + bool operator==(const StopAdminTaskRequest& rhs) const; +#ifndef SWIG + friend bool operator!=(const StopAdminTaskRequest& __x, const StopAdminTaskRequest& __y) { + return !(__x == __y); + } +#endif + bool operator<(const StopAdminTaskRequest& rhs) const; +#ifndef SWIG + friend bool operator>(const StopAdminTaskRequest& __x, const StopAdminTaskRequest& __y) { + return __y < __x; + } + friend bool operator<=(const StopAdminTaskRequest& __x, const StopAdminTaskRequest& __y) { + return !(__y < __x); + } + friend bool operator>=(const StopAdminTaskRequest& __x, const StopAdminTaskRequest& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref job_id_ref() const& { + return {this->job_id, __isset.job_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref job_id_ref() const&& { + return {std::move(this->job_id), __isset.job_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref job_id_ref() & { + return {this->job_id, __isset.job_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref job_id_ref() && { + return {std::move(this->job_id), __isset.job_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref task_id_ref() const& { + return {this->task_id, __isset.task_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref task_id_ref() const&& { + return {std::move(this->task_id), __isset.task_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref task_id_ref() & { + return {this->task_id, __isset.task_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref task_id_ref() && { + return {std::move(this->task_id), __isset.task_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + int32_t get_job_id() const { + return job_id; + } + + int32_t& set_job_id(int32_t job_id_) { + job_id = job_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.job_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return job_id; + } + + int32_t get_task_id() const { + return task_id; + } + + int32_t& set_task_id(int32_t task_id_) { + task_id = task_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.task_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return task_id; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< StopAdminTaskRequest >; + friend void swap(StopAdminTaskRequest& a, StopAdminTaskRequest& b); +}; + +template +uint32_t StopAdminTaskRequest::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { +class AdminExecResp final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = AdminExecResp; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + AdminExecResp() {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + AdminExecResp(apache::thrift::FragileConstructor, ::nebula::storage::cpp2::ResponseCommon result__arg, ::nebula::meta::cpp2::StatsItem stats__arg); + + AdminExecResp(AdminExecResp&&) = default; + + AdminExecResp(const AdminExecResp&) = default; + + + AdminExecResp& operator=(AdminExecResp&&) = default; + + AdminExecResp& operator=(const AdminExecResp&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + public: + ::nebula::storage::cpp2::ResponseCommon result; + private: + ::nebula::meta::cpp2::StatsItem stats; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool stats; + } __isset = {}; + bool operator==(const AdminExecResp& rhs) const; +#ifndef SWIG + friend bool operator!=(const AdminExecResp& __x, const AdminExecResp& __y) { + return !(__x == __y); + } +#endif + bool operator<(const AdminExecResp& rhs) const; +#ifndef SWIG + friend bool operator>(const AdminExecResp& __x, const AdminExecResp& __y) { + return __y < __x; + } + friend bool operator<=(const AdminExecResp& __x, const AdminExecResp& __y) { + return !(__y < __x); + } + friend bool operator>=(const AdminExecResp& __x, const AdminExecResp& __y) { + return !(__x < __y); + } +#endif + template + FOLLY_ERASE ::apache::thrift::required_field_ref result_ref() const& { + return ::apache::thrift::required_field_ref{this->result}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref result_ref() const&& { + return ::apache::thrift::required_field_ref{std::move(this->result)}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref result_ref() & { + return ::apache::thrift::required_field_ref{this->result}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref result_ref() && { + return ::apache::thrift::required_field_ref{std::move(this->result)}; + } + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::optional_field_ref stats_ref() const& { + return {this->stats, __isset.stats}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref stats_ref() const&& { + return {std::move(this->stats), __isset.stats}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref stats_ref() & { + return {this->stats, __isset.stats}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref stats_ref() && { + return {std::move(this->stats), __isset.stats}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + const ::nebula::storage::cpp2::ResponseCommon& get_result() const&; + ::nebula::storage::cpp2::ResponseCommon get_result() &&; + + template + ::nebula::storage::cpp2::ResponseCommon& set_result(T_AdminExecResp_result_struct_setter&& result_) { + result = std::forward(result_); + return result; + } + const ::nebula::meta::cpp2::StatsItem* get_stats() const&; + ::nebula::meta::cpp2::StatsItem* get_stats() &; + ::nebula::meta::cpp2::StatsItem* get_stats() && = delete; + + template + ::nebula::meta::cpp2::StatsItem& set_stats(T_AdminExecResp_stats_struct_setter&& stats_) { + stats = std::forward(stats_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.stats = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return stats; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< AdminExecResp >; + friend void swap(AdminExecResp& a, AdminExecResp& b); +}; + +template +uint32_t AdminExecResp::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { +class TransLeaderReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = TransLeaderReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + TransLeaderReq() : + space_id(0), + part_id(0) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + TransLeaderReq(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, ::nebula::cpp2::PartitionID part_id__arg, nebula::HostAddr new_leader__arg); + + TransLeaderReq(TransLeaderReq&&) = default; + + TransLeaderReq(const TransLeaderReq&) = default; + + + TransLeaderReq& operator=(TransLeaderReq&&) = default; + + TransLeaderReq& operator=(const TransLeaderReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::GraphSpaceID space_id; + private: + ::nebula::cpp2::PartitionID part_id; + private: + nebula::HostAddr new_leader; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool space_id; + bool part_id; + bool new_leader; + } __isset = {}; + bool operator==(const TransLeaderReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const TransLeaderReq& __x, const TransLeaderReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const TransLeaderReq& rhs) const; +#ifndef SWIG + friend bool operator>(const TransLeaderReq& __x, const TransLeaderReq& __y) { + return __y < __x; + } + friend bool operator<=(const TransLeaderReq& __x, const TransLeaderReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const TransLeaderReq& __x, const TransLeaderReq& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const& { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const&& { + return {std::move(this->space_id), __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() & { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() && { + return {std::move(this->space_id), __isset.space_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref part_id_ref() const& { + return {this->part_id, __isset.part_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref part_id_ref() const&& { + return {std::move(this->part_id), __isset.part_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref part_id_ref() & { + return {this->part_id, __isset.part_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref part_id_ref() && { + return {std::move(this->part_id), __isset.part_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref new_leader_ref() const& { + return {this->new_leader, __isset.new_leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref new_leader_ref() const&& { + return {std::move(this->new_leader), __isset.new_leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref new_leader_ref() & { + return {this->new_leader, __isset.new_leader}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref new_leader_ref() && { + return {std::move(this->new_leader), __isset.new_leader}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::GraphSpaceID get_space_id() const { + return space_id; + } + + ::nebula::cpp2::GraphSpaceID& set_space_id( ::nebula::cpp2::GraphSpaceID space_id_) { + space_id = space_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.space_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return space_id; + } + + ::nebula::cpp2::PartitionID get_part_id() const { + return part_id; + } + + ::nebula::cpp2::PartitionID& set_part_id( ::nebula::cpp2::PartitionID part_id_) { + part_id = part_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.part_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return part_id; + } + const nebula::HostAddr& get_new_leader() const&; + nebula::HostAddr get_new_leader() &&; + + template + nebula::HostAddr& set_new_leader(T_TransLeaderReq_new_leader_struct_setter&& new_leader_) { + new_leader = std::forward(new_leader_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.new_leader = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return new_leader; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< TransLeaderReq >; + friend void swap(TransLeaderReq& a, TransLeaderReq& b); +}; + +template +uint32_t TransLeaderReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { +class AddPartReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = AddPartReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + AddPartReq() : + space_id(0), + part_id(0), + as_learner(0) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + AddPartReq(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, ::nebula::cpp2::PartitionID part_id__arg, bool as_learner__arg, ::std::vector peers__arg); + + AddPartReq(AddPartReq&&) = default; + + AddPartReq(const AddPartReq&) = default; + + + AddPartReq& operator=(AddPartReq&&) = default; + + AddPartReq& operator=(const AddPartReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::GraphSpaceID space_id; + private: + ::nebula::cpp2::PartitionID part_id; + private: + bool as_learner; + private: + ::std::vector peers; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool space_id; + bool part_id; + bool as_learner; + bool peers; + } __isset = {}; + bool operator==(const AddPartReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const AddPartReq& __x, const AddPartReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const AddPartReq& rhs) const; +#ifndef SWIG + friend bool operator>(const AddPartReq& __x, const AddPartReq& __y) { + return __y < __x; + } + friend bool operator<=(const AddPartReq& __x, const AddPartReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const AddPartReq& __x, const AddPartReq& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const& { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const&& { + return {std::move(this->space_id), __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() & { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() && { + return {std::move(this->space_id), __isset.space_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref part_id_ref() const& { + return {this->part_id, __isset.part_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref part_id_ref() const&& { + return {std::move(this->part_id), __isset.part_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref part_id_ref() & { + return {this->part_id, __isset.part_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref part_id_ref() && { + return {std::move(this->part_id), __isset.part_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref as_learner_ref() const& { + return {this->as_learner, __isset.as_learner}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref as_learner_ref() const&& { + return {std::move(this->as_learner), __isset.as_learner}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref as_learner_ref() & { + return {this->as_learner, __isset.as_learner}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref as_learner_ref() && { + return {std::move(this->as_learner), __isset.as_learner}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::field_ref peers_ref() const& { + return {this->peers, __isset.peers}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref peers_ref() const&& { + return {std::move(this->peers), __isset.peers}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref peers_ref() & { + return {this->peers, __isset.peers}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref peers_ref() && { + return {std::move(this->peers), __isset.peers}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::GraphSpaceID get_space_id() const { + return space_id; + } + + ::nebula::cpp2::GraphSpaceID& set_space_id( ::nebula::cpp2::GraphSpaceID space_id_) { + space_id = space_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.space_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return space_id; + } + + ::nebula::cpp2::PartitionID get_part_id() const { + return part_id; + } + + ::nebula::cpp2::PartitionID& set_part_id( ::nebula::cpp2::PartitionID part_id_) { + part_id = part_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.part_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return part_id; + } + + bool get_as_learner() const { + return as_learner; + } + + bool& set_as_learner(bool as_learner_) { + as_learner = as_learner_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.as_learner = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return as_learner; + } + const ::std::vector& get_peers() const&; + ::std::vector get_peers() &&; + + template > + ::std::vector& set_peers(T_AddPartReq_peers_struct_setter&& peers_) { + peers = std::forward(peers_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.peers = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return peers; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< AddPartReq >; + friend void swap(AddPartReq& a, AddPartReq& b); +}; + +template +uint32_t AddPartReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { +class AddLearnerReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = AddLearnerReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + AddLearnerReq() : + space_id(0), + part_id(0) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + AddLearnerReq(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, ::nebula::cpp2::PartitionID part_id__arg, nebula::HostAddr learner__arg); + + AddLearnerReq(AddLearnerReq&&) = default; + + AddLearnerReq(const AddLearnerReq&) = default; + + + AddLearnerReq& operator=(AddLearnerReq&&) = default; + + AddLearnerReq& operator=(const AddLearnerReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::GraphSpaceID space_id; + private: + ::nebula::cpp2::PartitionID part_id; + private: + nebula::HostAddr learner; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool space_id; + bool part_id; + bool learner; + } __isset = {}; + bool operator==(const AddLearnerReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const AddLearnerReq& __x, const AddLearnerReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const AddLearnerReq& rhs) const; +#ifndef SWIG + friend bool operator>(const AddLearnerReq& __x, const AddLearnerReq& __y) { + return __y < __x; + } + friend bool operator<=(const AddLearnerReq& __x, const AddLearnerReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const AddLearnerReq& __x, const AddLearnerReq& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const& { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const&& { + return {std::move(this->space_id), __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() & { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() && { + return {std::move(this->space_id), __isset.space_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref part_id_ref() const& { + return {this->part_id, __isset.part_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref part_id_ref() const&& { + return {std::move(this->part_id), __isset.part_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref part_id_ref() & { + return {this->part_id, __isset.part_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref part_id_ref() && { + return {std::move(this->part_id), __isset.part_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref learner_ref() const& { + return {this->learner, __isset.learner}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref learner_ref() const&& { + return {std::move(this->learner), __isset.learner}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref learner_ref() & { + return {this->learner, __isset.learner}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref learner_ref() && { + return {std::move(this->learner), __isset.learner}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::GraphSpaceID get_space_id() const { + return space_id; + } + + ::nebula::cpp2::GraphSpaceID& set_space_id( ::nebula::cpp2::GraphSpaceID space_id_) { + space_id = space_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.space_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return space_id; + } + + ::nebula::cpp2::PartitionID get_part_id() const { + return part_id; + } + + ::nebula::cpp2::PartitionID& set_part_id( ::nebula::cpp2::PartitionID part_id_) { + part_id = part_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.part_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return part_id; + } + const nebula::HostAddr& get_learner() const&; + nebula::HostAddr get_learner() &&; + + template + nebula::HostAddr& set_learner(T_AddLearnerReq_learner_struct_setter&& learner_) { + learner = std::forward(learner_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.learner = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return learner; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< AddLearnerReq >; + friend void swap(AddLearnerReq& a, AddLearnerReq& b); +}; + +template +uint32_t AddLearnerReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { +class RemovePartReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = RemovePartReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + RemovePartReq() : + space_id(0), + part_id(0) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + RemovePartReq(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, ::nebula::cpp2::PartitionID part_id__arg); + + RemovePartReq(RemovePartReq&&) = default; + + RemovePartReq(const RemovePartReq&) = default; + + + RemovePartReq& operator=(RemovePartReq&&) = default; + + RemovePartReq& operator=(const RemovePartReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::GraphSpaceID space_id; + private: + ::nebula::cpp2::PartitionID part_id; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool space_id; + bool part_id; + } __isset = {}; + bool operator==(const RemovePartReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const RemovePartReq& __x, const RemovePartReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const RemovePartReq& rhs) const; +#ifndef SWIG + friend bool operator>(const RemovePartReq& __x, const RemovePartReq& __y) { + return __y < __x; + } + friend bool operator<=(const RemovePartReq& __x, const RemovePartReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const RemovePartReq& __x, const RemovePartReq& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const& { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const&& { + return {std::move(this->space_id), __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() & { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() && { + return {std::move(this->space_id), __isset.space_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref part_id_ref() const& { + return {this->part_id, __isset.part_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref part_id_ref() const&& { + return {std::move(this->part_id), __isset.part_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref part_id_ref() & { + return {this->part_id, __isset.part_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref part_id_ref() && { + return {std::move(this->part_id), __isset.part_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::GraphSpaceID get_space_id() const { + return space_id; + } + + ::nebula::cpp2::GraphSpaceID& set_space_id( ::nebula::cpp2::GraphSpaceID space_id_) { + space_id = space_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.space_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return space_id; + } + + ::nebula::cpp2::PartitionID get_part_id() const { + return part_id; + } + + ::nebula::cpp2::PartitionID& set_part_id( ::nebula::cpp2::PartitionID part_id_) { + part_id = part_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.part_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return part_id; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< RemovePartReq >; + friend void swap(RemovePartReq& a, RemovePartReq& b); +}; + +template +uint32_t RemovePartReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { +class MemberChangeReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = MemberChangeReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + MemberChangeReq() : + space_id(0), + part_id(0), + add(0) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + MemberChangeReq(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, ::nebula::cpp2::PartitionID part_id__arg, nebula::HostAddr peer__arg, bool add__arg); + + MemberChangeReq(MemberChangeReq&&) = default; + + MemberChangeReq(const MemberChangeReq&) = default; + + + MemberChangeReq& operator=(MemberChangeReq&&) = default; + + MemberChangeReq& operator=(const MemberChangeReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::GraphSpaceID space_id; + private: + ::nebula::cpp2::PartitionID part_id; + private: + nebula::HostAddr peer; + private: + bool add; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool space_id; + bool part_id; + bool peer; + bool add; + } __isset = {}; + bool operator==(const MemberChangeReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const MemberChangeReq& __x, const MemberChangeReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const MemberChangeReq& rhs) const; +#ifndef SWIG + friend bool operator>(const MemberChangeReq& __x, const MemberChangeReq& __y) { + return __y < __x; + } + friend bool operator<=(const MemberChangeReq& __x, const MemberChangeReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const MemberChangeReq& __x, const MemberChangeReq& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const& { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const&& { + return {std::move(this->space_id), __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() & { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() && { + return {std::move(this->space_id), __isset.space_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref part_id_ref() const& { + return {this->part_id, __isset.part_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref part_id_ref() const&& { + return {std::move(this->part_id), __isset.part_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref part_id_ref() & { + return {this->part_id, __isset.part_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref part_id_ref() && { + return {std::move(this->part_id), __isset.part_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref peer_ref() const& { + return {this->peer, __isset.peer}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref peer_ref() const&& { + return {std::move(this->peer), __isset.peer}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref peer_ref() & { + return {this->peer, __isset.peer}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref peer_ref() && { + return {std::move(this->peer), __isset.peer}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref add_ref() const& { + return {this->add, __isset.add}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref add_ref() const&& { + return {std::move(this->add), __isset.add}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref add_ref() & { + return {this->add, __isset.add}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref add_ref() && { + return {std::move(this->add), __isset.add}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::GraphSpaceID get_space_id() const { + return space_id; + } + + ::nebula::cpp2::GraphSpaceID& set_space_id( ::nebula::cpp2::GraphSpaceID space_id_) { + space_id = space_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.space_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return space_id; + } + + ::nebula::cpp2::PartitionID get_part_id() const { + return part_id; + } + + ::nebula::cpp2::PartitionID& set_part_id( ::nebula::cpp2::PartitionID part_id_) { + part_id = part_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.part_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return part_id; + } + const nebula::HostAddr& get_peer() const&; + nebula::HostAddr get_peer() &&; + + template + nebula::HostAddr& set_peer(T_MemberChangeReq_peer_struct_setter&& peer_) { + peer = std::forward(peer_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.peer = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return peer; + } + + bool get_add() const { + return add; + } + + bool& set_add(bool add_) { + add = add_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.add = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return add; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< MemberChangeReq >; + friend void swap(MemberChangeReq& a, MemberChangeReq& b); +}; + +template +uint32_t MemberChangeReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { +class CatchUpDataReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = CatchUpDataReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + CatchUpDataReq() : + space_id(0), + part_id(0) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + CatchUpDataReq(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, ::nebula::cpp2::PartitionID part_id__arg, nebula::HostAddr target__arg); + + CatchUpDataReq(CatchUpDataReq&&) = default; + + CatchUpDataReq(const CatchUpDataReq&) = default; + + + CatchUpDataReq& operator=(CatchUpDataReq&&) = default; + + CatchUpDataReq& operator=(const CatchUpDataReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::GraphSpaceID space_id; + private: + ::nebula::cpp2::PartitionID part_id; + private: + nebula::HostAddr target; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool space_id; + bool part_id; + bool target; + } __isset = {}; + bool operator==(const CatchUpDataReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const CatchUpDataReq& __x, const CatchUpDataReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const CatchUpDataReq& rhs) const; +#ifndef SWIG + friend bool operator>(const CatchUpDataReq& __x, const CatchUpDataReq& __y) { + return __y < __x; + } + friend bool operator<=(const CatchUpDataReq& __x, const CatchUpDataReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const CatchUpDataReq& __x, const CatchUpDataReq& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const& { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const&& { + return {std::move(this->space_id), __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() & { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() && { + return {std::move(this->space_id), __isset.space_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref part_id_ref() const& { + return {this->part_id, __isset.part_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref part_id_ref() const&& { + return {std::move(this->part_id), __isset.part_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref part_id_ref() & { + return {this->part_id, __isset.part_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref part_id_ref() && { + return {std::move(this->part_id), __isset.part_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref target_ref() const& { + return {this->target, __isset.target}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref target_ref() const&& { + return {std::move(this->target), __isset.target}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref target_ref() & { + return {this->target, __isset.target}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref target_ref() && { + return {std::move(this->target), __isset.target}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::GraphSpaceID get_space_id() const { + return space_id; + } + + ::nebula::cpp2::GraphSpaceID& set_space_id( ::nebula::cpp2::GraphSpaceID space_id_) { + space_id = space_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.space_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return space_id; + } + + ::nebula::cpp2::PartitionID get_part_id() const { + return part_id; + } + + ::nebula::cpp2::PartitionID& set_part_id( ::nebula::cpp2::PartitionID part_id_) { + part_id = part_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.part_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return part_id; + } + const nebula::HostAddr& get_target() const&; + nebula::HostAddr get_target() &&; + + template + nebula::HostAddr& set_target(T_CatchUpDataReq_target_struct_setter&& target_) { + target = std::forward(target_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.target = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return target; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< CatchUpDataReq >; + friend void swap(CatchUpDataReq& a, CatchUpDataReq& b); +}; + +template +uint32_t CatchUpDataReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { +class GetLeaderReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = GetLeaderReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + GetLeaderReq() {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + GetLeaderReq(apache::thrift::FragileConstructor); + + GetLeaderReq(GetLeaderReq&&) = default; + + GetLeaderReq(const GetLeaderReq&) = default; + + + GetLeaderReq& operator=(GetLeaderReq&&) = default; + + GetLeaderReq& operator=(const GetLeaderReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + bool operator==(const GetLeaderReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const GetLeaderReq& __x, const GetLeaderReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const GetLeaderReq& rhs) const; +#ifndef SWIG + friend bool operator>(const GetLeaderReq& __x, const GetLeaderReq& __y) { + return __y < __x; + } + friend bool operator<=(const GetLeaderReq& __x, const GetLeaderReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const GetLeaderReq& __x, const GetLeaderReq& __y) { + return !(__x < __y); + } +#endif + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< GetLeaderReq >; + friend void swap(GetLeaderReq& a, GetLeaderReq& b); +}; + +template +uint32_t GetLeaderReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { +class CreateCPRequest final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = CreateCPRequest; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + CreateCPRequest() : + space_id(0) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + CreateCPRequest(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, ::std::string name__arg); + + CreateCPRequest(CreateCPRequest&&) = default; + + CreateCPRequest(const CreateCPRequest&) = default; + + + CreateCPRequest& operator=(CreateCPRequest&&) = default; + + CreateCPRequest& operator=(const CreateCPRequest&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::GraphSpaceID space_id; + private: + ::std::string name; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool space_id; + bool name; + } __isset = {}; + bool operator==(const CreateCPRequest& rhs) const; +#ifndef SWIG + friend bool operator!=(const CreateCPRequest& __x, const CreateCPRequest& __y) { + return !(__x == __y); + } +#endif + bool operator<(const CreateCPRequest& rhs) const; +#ifndef SWIG + friend bool operator>(const CreateCPRequest& __x, const CreateCPRequest& __y) { + return __y < __x; + } + friend bool operator<=(const CreateCPRequest& __x, const CreateCPRequest& __y) { + return !(__y < __x); + } + friend bool operator>=(const CreateCPRequest& __x, const CreateCPRequest& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const& { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const&& { + return {std::move(this->space_id), __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() & { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() && { + return {std::move(this->space_id), __isset.space_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref name_ref() const& { + return {this->name, __isset.name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref name_ref() const&& { + return {std::move(this->name), __isset.name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref name_ref() & { + return {this->name, __isset.name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref name_ref() && { + return {std::move(this->name), __isset.name}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::GraphSpaceID get_space_id() const { + return space_id; + } + + ::nebula::cpp2::GraphSpaceID& set_space_id( ::nebula::cpp2::GraphSpaceID space_id_) { + space_id = space_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.space_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return space_id; + } + + const ::std::string& get_name() const& { + return name; + } + + ::std::string get_name() && { + return std::move(name); + } + + template + ::std::string& set_name(T_CreateCPRequest_name_struct_setter&& name_) { + name = std::forward(name_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.name = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return name; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< CreateCPRequest >; + friend void swap(CreateCPRequest& a, CreateCPRequest& b); +}; + +template +uint32_t CreateCPRequest::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { +class DropCPRequest final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = DropCPRequest; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + DropCPRequest() : + space_id(0) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + DropCPRequest(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, ::std::string name__arg); + + DropCPRequest(DropCPRequest&&) = default; + + DropCPRequest(const DropCPRequest&) = default; + + + DropCPRequest& operator=(DropCPRequest&&) = default; + + DropCPRequest& operator=(const DropCPRequest&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::GraphSpaceID space_id; + private: + ::std::string name; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool space_id; + bool name; + } __isset = {}; + bool operator==(const DropCPRequest& rhs) const; +#ifndef SWIG + friend bool operator!=(const DropCPRequest& __x, const DropCPRequest& __y) { + return !(__x == __y); + } +#endif + bool operator<(const DropCPRequest& rhs) const; +#ifndef SWIG + friend bool operator>(const DropCPRequest& __x, const DropCPRequest& __y) { + return __y < __x; + } + friend bool operator<=(const DropCPRequest& __x, const DropCPRequest& __y) { + return !(__y < __x); + } + friend bool operator>=(const DropCPRequest& __x, const DropCPRequest& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const& { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const&& { + return {std::move(this->space_id), __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() & { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() && { + return {std::move(this->space_id), __isset.space_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref name_ref() const& { + return {this->name, __isset.name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref name_ref() const&& { + return {std::move(this->name), __isset.name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref name_ref() & { + return {this->name, __isset.name}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref name_ref() && { + return {std::move(this->name), __isset.name}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::GraphSpaceID get_space_id() const { + return space_id; + } + + ::nebula::cpp2::GraphSpaceID& set_space_id( ::nebula::cpp2::GraphSpaceID space_id_) { + space_id = space_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.space_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return space_id; + } + + const ::std::string& get_name() const& { + return name; + } + + ::std::string get_name() && { + return std::move(name); + } + + template + ::std::string& set_name(T_DropCPRequest_name_struct_setter&& name_) { + name = std::forward(name_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.name = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return name; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< DropCPRequest >; + friend void swap(DropCPRequest& a, DropCPRequest& b); +}; + +template +uint32_t DropCPRequest::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { +class BlockingSignRequest final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = BlockingSignRequest; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + BlockingSignRequest() : + space_id(0), + sign(static_cast< ::nebula::storage::cpp2::EngineSignType>(0)) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + BlockingSignRequest(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, ::nebula::storage::cpp2::EngineSignType sign__arg); + + BlockingSignRequest(BlockingSignRequest&&) = default; + + BlockingSignRequest(const BlockingSignRequest&) = default; + + + BlockingSignRequest& operator=(BlockingSignRequest&&) = default; + + BlockingSignRequest& operator=(const BlockingSignRequest&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::GraphSpaceID space_id; + public: + ::nebula::storage::cpp2::EngineSignType sign; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool space_id; + } __isset = {}; + bool operator==(const BlockingSignRequest& rhs) const; +#ifndef SWIG + friend bool operator!=(const BlockingSignRequest& __x, const BlockingSignRequest& __y) { + return !(__x == __y); + } +#endif + bool operator<(const BlockingSignRequest& rhs) const; +#ifndef SWIG + friend bool operator>(const BlockingSignRequest& __x, const BlockingSignRequest& __y) { + return __y < __x; + } + friend bool operator<=(const BlockingSignRequest& __x, const BlockingSignRequest& __y) { + return !(__y < __x); + } + friend bool operator>=(const BlockingSignRequest& __x, const BlockingSignRequest& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const& { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const&& { + return {std::move(this->space_id), __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() & { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() && { + return {std::move(this->space_id), __isset.space_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + template + FOLLY_ERASE ::apache::thrift::required_field_ref sign_ref() const& { + return ::apache::thrift::required_field_ref{this->sign}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref sign_ref() const&& { + return ::apache::thrift::required_field_ref{std::move(this->sign)}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref sign_ref() & { + return ::apache::thrift::required_field_ref{this->sign}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref sign_ref() && { + return ::apache::thrift::required_field_ref{std::move(this->sign)}; + } + + ::nebula::cpp2::GraphSpaceID get_space_id() const { + return space_id; + } + + ::nebula::cpp2::GraphSpaceID& set_space_id( ::nebula::cpp2::GraphSpaceID space_id_) { + space_id = space_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.space_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return space_id; + } + + ::nebula::storage::cpp2::EngineSignType get_sign() const { + return sign; + } + + ::nebula::storage::cpp2::EngineSignType& set_sign( ::nebula::storage::cpp2::EngineSignType sign_) { + sign = sign_; + return sign; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< BlockingSignRequest >; + friend void swap(BlockingSignRequest& a, BlockingSignRequest& b); +}; + +template +uint32_t BlockingSignRequest::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { +class GetLeaderPartsResp final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = GetLeaderPartsResp; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + GetLeaderPartsResp() {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + GetLeaderPartsResp(apache::thrift::FragileConstructor, ::nebula::storage::cpp2::ResponseCommon result__arg, std::unordered_map< ::nebula::cpp2::GraphSpaceID, ::std::vector< ::nebula::cpp2::PartitionID>> leader_parts__arg); + + GetLeaderPartsResp(GetLeaderPartsResp&&) = default; + + GetLeaderPartsResp(const GetLeaderPartsResp&) = default; + + + GetLeaderPartsResp& operator=(GetLeaderPartsResp&&) = default; + + GetLeaderPartsResp& operator=(const GetLeaderPartsResp&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + public: + ::nebula::storage::cpp2::ResponseCommon result; + private: + std::unordered_map< ::nebula::cpp2::GraphSpaceID, ::std::vector< ::nebula::cpp2::PartitionID>> leader_parts; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool leader_parts; + } __isset = {}; + bool operator==(const GetLeaderPartsResp& rhs) const; +#ifndef SWIG + friend bool operator!=(const GetLeaderPartsResp& __x, const GetLeaderPartsResp& __y) { + return !(__x == __y); + } +#endif + bool operator<(const GetLeaderPartsResp& rhs) const; +#ifndef SWIG + friend bool operator>(const GetLeaderPartsResp& __x, const GetLeaderPartsResp& __y) { + return __y < __x; + } + friend bool operator<=(const GetLeaderPartsResp& __x, const GetLeaderPartsResp& __y) { + return !(__y < __x); + } + friend bool operator>=(const GetLeaderPartsResp& __x, const GetLeaderPartsResp& __y) { + return !(__x < __y); + } +#endif + template + FOLLY_ERASE ::apache::thrift::required_field_ref result_ref() const& { + return ::apache::thrift::required_field_ref{this->result}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref result_ref() const&& { + return ::apache::thrift::required_field_ref{std::move(this->result)}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref result_ref() & { + return ::apache::thrift::required_field_ref{this->result}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref result_ref() && { + return ::apache::thrift::required_field_ref{std::move(this->result)}; + } + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template >> + FOLLY_ERASE ::apache::thrift::field_ref leader_parts_ref() const& { + return {this->leader_parts, __isset.leader_parts}; + } + + template >> + FOLLY_ERASE ::apache::thrift::field_ref leader_parts_ref() const&& { + return {std::move(this->leader_parts), __isset.leader_parts}; + } + + template >> + FOLLY_ERASE ::apache::thrift::field_ref leader_parts_ref() & { + return {this->leader_parts, __isset.leader_parts}; + } + + template >> + FOLLY_ERASE ::apache::thrift::field_ref leader_parts_ref() && { + return {std::move(this->leader_parts), __isset.leader_parts}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + const ::nebula::storage::cpp2::ResponseCommon& get_result() const&; + ::nebula::storage::cpp2::ResponseCommon get_result() &&; + + template + ::nebula::storage::cpp2::ResponseCommon& set_result(T_GetLeaderPartsResp_result_struct_setter&& result_) { + result = std::forward(result_); + return result; + } + const std::unordered_map< ::nebula::cpp2::GraphSpaceID, ::std::vector< ::nebula::cpp2::PartitionID>>& get_leader_parts() const&; + std::unordered_map< ::nebula::cpp2::GraphSpaceID, ::std::vector< ::nebula::cpp2::PartitionID>> get_leader_parts() &&; + + template >> + std::unordered_map< ::nebula::cpp2::GraphSpaceID, ::std::vector< ::nebula::cpp2::PartitionID>>& set_leader_parts(T_GetLeaderPartsResp_leader_parts_struct_setter&& leader_parts_) { + leader_parts = std::forward(leader_parts_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.leader_parts = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return leader_parts; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< GetLeaderPartsResp >; + friend void swap(GetLeaderPartsResp& a, GetLeaderPartsResp& b); +}; + +template +uint32_t GetLeaderPartsResp::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { +class CheckPeersReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = CheckPeersReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + CheckPeersReq() : + space_id(0), + part_id(0) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + CheckPeersReq(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, ::nebula::cpp2::PartitionID part_id__arg, ::std::vector peers__arg); + + CheckPeersReq(CheckPeersReq&&) = default; + + CheckPeersReq(const CheckPeersReq&) = default; + + + CheckPeersReq& operator=(CheckPeersReq&&) = default; + + CheckPeersReq& operator=(const CheckPeersReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::GraphSpaceID space_id; + private: + ::nebula::cpp2::PartitionID part_id; + private: + ::std::vector peers; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool space_id; + bool part_id; + bool peers; + } __isset = {}; + bool operator==(const CheckPeersReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const CheckPeersReq& __x, const CheckPeersReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const CheckPeersReq& rhs) const; +#ifndef SWIG + friend bool operator>(const CheckPeersReq& __x, const CheckPeersReq& __y) { + return __y < __x; + } + friend bool operator<=(const CheckPeersReq& __x, const CheckPeersReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const CheckPeersReq& __x, const CheckPeersReq& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const& { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const&& { + return {std::move(this->space_id), __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() & { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() && { + return {std::move(this->space_id), __isset.space_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref part_id_ref() const& { + return {this->part_id, __isset.part_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref part_id_ref() const&& { + return {std::move(this->part_id), __isset.part_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref part_id_ref() & { + return {this->part_id, __isset.part_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref part_id_ref() && { + return {std::move(this->part_id), __isset.part_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::field_ref peers_ref() const& { + return {this->peers, __isset.peers}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref peers_ref() const&& { + return {std::move(this->peers), __isset.peers}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref peers_ref() & { + return {this->peers, __isset.peers}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref peers_ref() && { + return {std::move(this->peers), __isset.peers}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::GraphSpaceID get_space_id() const { + return space_id; + } + + ::nebula::cpp2::GraphSpaceID& set_space_id( ::nebula::cpp2::GraphSpaceID space_id_) { + space_id = space_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.space_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return space_id; + } + + ::nebula::cpp2::PartitionID get_part_id() const { + return part_id; + } + + ::nebula::cpp2::PartitionID& set_part_id( ::nebula::cpp2::PartitionID part_id_) { + part_id = part_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.part_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return part_id; + } + const ::std::vector& get_peers() const&; + ::std::vector get_peers() &&; + + template > + ::std::vector& set_peers(T_CheckPeersReq_peers_struct_setter&& peers_) { + peers = std::forward(peers_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.peers = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return peers; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< CheckPeersReq >; + friend void swap(CheckPeersReq& a, CheckPeersReq& b); +}; + +template +uint32_t CheckPeersReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { +class RebuildIndexRequest final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = RebuildIndexRequest; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + RebuildIndexRequest() : + space_id(0), + index_id(0) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + RebuildIndexRequest(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, ::std::vector< ::nebula::cpp2::PartitionID> parts__arg, ::nebula::cpp2::IndexID index_id__arg); + + RebuildIndexRequest(RebuildIndexRequest&&) = default; + + RebuildIndexRequest(const RebuildIndexRequest&) = default; + + + RebuildIndexRequest& operator=(RebuildIndexRequest&&) = default; + + RebuildIndexRequest& operator=(const RebuildIndexRequest&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::GraphSpaceID space_id; + private: + ::std::vector< ::nebula::cpp2::PartitionID> parts; + private: + ::nebula::cpp2::IndexID index_id; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool space_id; + bool parts; + bool index_id; + } __isset = {}; + bool operator==(const RebuildIndexRequest& rhs) const; +#ifndef SWIG + friend bool operator!=(const RebuildIndexRequest& __x, const RebuildIndexRequest& __y) { + return !(__x == __y); + } +#endif + bool operator<(const RebuildIndexRequest& rhs) const; +#ifndef SWIG + friend bool operator>(const RebuildIndexRequest& __x, const RebuildIndexRequest& __y) { + return __y < __x; + } + friend bool operator<=(const RebuildIndexRequest& __x, const RebuildIndexRequest& __y) { + return !(__y < __x); + } + friend bool operator>=(const RebuildIndexRequest& __x, const RebuildIndexRequest& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const& { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const&& { + return {std::move(this->space_id), __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() & { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() && { + return {std::move(this->space_id), __isset.space_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::field_ref parts_ref() const& { + return {this->parts, __isset.parts}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref parts_ref() const&& { + return {std::move(this->parts), __isset.parts}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref parts_ref() & { + return {this->parts, __isset.parts}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref parts_ref() && { + return {std::move(this->parts), __isset.parts}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref index_id_ref() const& { + return {this->index_id, __isset.index_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref index_id_ref() const&& { + return {std::move(this->index_id), __isset.index_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref index_id_ref() & { + return {this->index_id, __isset.index_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref index_id_ref() && { + return {std::move(this->index_id), __isset.index_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::GraphSpaceID get_space_id() const { + return space_id; + } + + ::nebula::cpp2::GraphSpaceID& set_space_id( ::nebula::cpp2::GraphSpaceID space_id_) { + space_id = space_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.space_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return space_id; + } + const ::std::vector< ::nebula::cpp2::PartitionID>& get_parts() const&; + ::std::vector< ::nebula::cpp2::PartitionID> get_parts() &&; + + template > + ::std::vector< ::nebula::cpp2::PartitionID>& set_parts(T_RebuildIndexRequest_parts_struct_setter&& parts_) { + parts = std::forward(parts_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.parts = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return parts; + } + + ::nebula::cpp2::IndexID get_index_id() const { + return index_id; + } + + ::nebula::cpp2::IndexID& set_index_id( ::nebula::cpp2::IndexID index_id_) { + index_id = index_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.index_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return index_id; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< RebuildIndexRequest >; + friend void swap(RebuildIndexRequest& a, RebuildIndexRequest& b); +}; + +template +uint32_t RebuildIndexRequest::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { +class CreateCPResp final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = CreateCPResp; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + CreateCPResp() {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + CreateCPResp(apache::thrift::FragileConstructor, ::nebula::storage::cpp2::ResponseCommon result__arg, ::std::vector< ::nebula::cpp2::CheckpointInfo> info__arg); + + CreateCPResp(CreateCPResp&&) = default; + + CreateCPResp(const CreateCPResp&) = default; + + + CreateCPResp& operator=(CreateCPResp&&) = default; + + CreateCPResp& operator=(const CreateCPResp&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + public: + ::nebula::storage::cpp2::ResponseCommon result; + private: + ::std::vector< ::nebula::cpp2::CheckpointInfo> info; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool info; + } __isset = {}; + bool operator==(const CreateCPResp& rhs) const; +#ifndef SWIG + friend bool operator!=(const CreateCPResp& __x, const CreateCPResp& __y) { + return !(__x == __y); + } +#endif + bool operator<(const CreateCPResp& rhs) const; +#ifndef SWIG + friend bool operator>(const CreateCPResp& __x, const CreateCPResp& __y) { + return __y < __x; + } + friend bool operator<=(const CreateCPResp& __x, const CreateCPResp& __y) { + return !(__y < __x); + } + friend bool operator>=(const CreateCPResp& __x, const CreateCPResp& __y) { + return !(__x < __y); + } +#endif + template + FOLLY_ERASE ::apache::thrift::required_field_ref result_ref() const& { + return ::apache::thrift::required_field_ref{this->result}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref result_ref() const&& { + return ::apache::thrift::required_field_ref{std::move(this->result)}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref result_ref() & { + return ::apache::thrift::required_field_ref{this->result}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref result_ref() && { + return ::apache::thrift::required_field_ref{std::move(this->result)}; + } + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::field_ref info_ref() const& { + return {this->info, __isset.info}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref info_ref() const&& { + return {std::move(this->info), __isset.info}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref info_ref() & { + return {this->info, __isset.info}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref info_ref() && { + return {std::move(this->info), __isset.info}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + const ::nebula::storage::cpp2::ResponseCommon& get_result() const&; + ::nebula::storage::cpp2::ResponseCommon get_result() &&; + + template + ::nebula::storage::cpp2::ResponseCommon& set_result(T_CreateCPResp_result_struct_setter&& result_) { + result = std::forward(result_); + return result; + } + const ::std::vector< ::nebula::cpp2::CheckpointInfo>& get_info() const&; + ::std::vector< ::nebula::cpp2::CheckpointInfo> get_info() &&; + + template > + ::std::vector< ::nebula::cpp2::CheckpointInfo>& set_info(T_CreateCPResp_info_struct_setter&& info_) { + info = std::forward(info_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.info = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return info; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< CreateCPResp >; + friend void swap(CreateCPResp& a, CreateCPResp& b); +}; + +template +uint32_t CreateCPResp::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { +class ListClusterInfoResp final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = ListClusterInfoResp; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + ListClusterInfoResp() {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + ListClusterInfoResp(apache::thrift::FragileConstructor, ::nebula::storage::cpp2::ResponseCommon result__arg, ::nebula::cpp2::DirInfo dir__arg); + + ListClusterInfoResp(ListClusterInfoResp&&) = default; + + ListClusterInfoResp(const ListClusterInfoResp&) = default; + + + ListClusterInfoResp& operator=(ListClusterInfoResp&&) = default; + + ListClusterInfoResp& operator=(const ListClusterInfoResp&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + public: + ::nebula::storage::cpp2::ResponseCommon result; + private: + ::nebula::cpp2::DirInfo dir; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool dir; + } __isset = {}; + bool operator==(const ListClusterInfoResp& rhs) const; +#ifndef SWIG + friend bool operator!=(const ListClusterInfoResp& __x, const ListClusterInfoResp& __y) { + return !(__x == __y); + } +#endif + bool operator<(const ListClusterInfoResp& rhs) const; +#ifndef SWIG + friend bool operator>(const ListClusterInfoResp& __x, const ListClusterInfoResp& __y) { + return __y < __x; + } + friend bool operator<=(const ListClusterInfoResp& __x, const ListClusterInfoResp& __y) { + return !(__y < __x); + } + friend bool operator>=(const ListClusterInfoResp& __x, const ListClusterInfoResp& __y) { + return !(__x < __y); + } +#endif + template + FOLLY_ERASE ::apache::thrift::required_field_ref result_ref() const& { + return ::apache::thrift::required_field_ref{this->result}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref result_ref() const&& { + return ::apache::thrift::required_field_ref{std::move(this->result)}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref result_ref() & { + return ::apache::thrift::required_field_ref{this->result}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref result_ref() && { + return ::apache::thrift::required_field_ref{std::move(this->result)}; + } + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref dir_ref() const& { + return {this->dir, __isset.dir}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref dir_ref() const&& { + return {std::move(this->dir), __isset.dir}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref dir_ref() & { + return {this->dir, __isset.dir}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref dir_ref() && { + return {std::move(this->dir), __isset.dir}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + const ::nebula::storage::cpp2::ResponseCommon& get_result() const&; + ::nebula::storage::cpp2::ResponseCommon get_result() &&; + + template + ::nebula::storage::cpp2::ResponseCommon& set_result(T_ListClusterInfoResp_result_struct_setter&& result_) { + result = std::forward(result_); + return result; + } + const ::nebula::cpp2::DirInfo& get_dir() const&; + ::nebula::cpp2::DirInfo get_dir() &&; + + template + ::nebula::cpp2::DirInfo& set_dir(T_ListClusterInfoResp_dir_struct_setter&& dir_) { + dir = std::forward(dir_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.dir = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return dir; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< ListClusterInfoResp >; + friend void swap(ListClusterInfoResp& a, ListClusterInfoResp& b); +}; + +template +uint32_t ListClusterInfoResp::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { +class ListClusterInfoReq final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = ListClusterInfoReq; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + ListClusterInfoReq() {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + ListClusterInfoReq(apache::thrift::FragileConstructor); + + ListClusterInfoReq(ListClusterInfoReq&&) = default; + + ListClusterInfoReq(const ListClusterInfoReq&) = default; + + + ListClusterInfoReq& operator=(ListClusterInfoReq&&) = default; + + ListClusterInfoReq& operator=(const ListClusterInfoReq&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + bool operator==(const ListClusterInfoReq& rhs) const; +#ifndef SWIG + friend bool operator!=(const ListClusterInfoReq& __x, const ListClusterInfoReq& __y) { + return !(__x == __y); + } +#endif + bool operator<(const ListClusterInfoReq& rhs) const; +#ifndef SWIG + friend bool operator>(const ListClusterInfoReq& __x, const ListClusterInfoReq& __y) { + return __y < __x; + } + friend bool operator<=(const ListClusterInfoReq& __x, const ListClusterInfoReq& __y) { + return !(__y < __x); + } + friend bool operator>=(const ListClusterInfoReq& __x, const ListClusterInfoReq& __y) { + return !(__x < __y); + } +#endif + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< ListClusterInfoReq >; + friend void swap(ListClusterInfoReq& a, ListClusterInfoReq& b); +}; + +template +uint32_t ListClusterInfoReq::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { +class KVGetRequest final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = KVGetRequest; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + KVGetRequest() : + space_id(0), + return_partly(0) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + KVGetRequest(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector<::std::string>> parts__arg, bool return_partly__arg); + + KVGetRequest(KVGetRequest&&) = default; + + KVGetRequest(const KVGetRequest&) = default; + + + KVGetRequest& operator=(KVGetRequest&&) = default; + + KVGetRequest& operator=(const KVGetRequest&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::GraphSpaceID space_id; + private: + std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector<::std::string>> parts; + private: + bool return_partly; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool space_id; + bool parts; + bool return_partly; + } __isset = {}; + bool operator==(const KVGetRequest& rhs) const; +#ifndef SWIG + friend bool operator!=(const KVGetRequest& __x, const KVGetRequest& __y) { + return !(__x == __y); + } +#endif + bool operator<(const KVGetRequest& rhs) const; +#ifndef SWIG + friend bool operator>(const KVGetRequest& __x, const KVGetRequest& __y) { + return __y < __x; + } + friend bool operator<=(const KVGetRequest& __x, const KVGetRequest& __y) { + return !(__y < __x); + } + friend bool operator>=(const KVGetRequest& __x, const KVGetRequest& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const& { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const&& { + return {std::move(this->space_id), __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() & { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() && { + return {std::move(this->space_id), __isset.space_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template >> + FOLLY_ERASE ::apache::thrift::field_ref parts_ref() const& { + return {this->parts, __isset.parts}; + } + + template >> + FOLLY_ERASE ::apache::thrift::field_ref parts_ref() const&& { + return {std::move(this->parts), __isset.parts}; + } + + template >> + FOLLY_ERASE ::apache::thrift::field_ref parts_ref() & { + return {this->parts, __isset.parts}; + } + + template >> + FOLLY_ERASE ::apache::thrift::field_ref parts_ref() && { + return {std::move(this->parts), __isset.parts}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref return_partly_ref() const& { + return {this->return_partly, __isset.return_partly}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref return_partly_ref() const&& { + return {std::move(this->return_partly), __isset.return_partly}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref return_partly_ref() & { + return {this->return_partly, __isset.return_partly}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref return_partly_ref() && { + return {std::move(this->return_partly), __isset.return_partly}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::GraphSpaceID get_space_id() const { + return space_id; + } + + ::nebula::cpp2::GraphSpaceID& set_space_id( ::nebula::cpp2::GraphSpaceID space_id_) { + space_id = space_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.space_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return space_id; + } + const std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector<::std::string>>& get_parts() const&; + std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector<::std::string>> get_parts() &&; + + template >> + std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector<::std::string>>& set_parts(T_KVGetRequest_parts_struct_setter&& parts_) { + parts = std::forward(parts_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.parts = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return parts; + } + + bool get_return_partly() const { + return return_partly; + } + + bool& set_return_partly(bool return_partly_) { + return_partly = return_partly_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.return_partly = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return return_partly; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< KVGetRequest >; + friend void swap(KVGetRequest& a, KVGetRequest& b); +}; + +template +uint32_t KVGetRequest::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { +class KVGetResponse final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = KVGetResponse; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + KVGetResponse() {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + KVGetResponse(apache::thrift::FragileConstructor, ::nebula::storage::cpp2::ResponseCommon result__arg, std::unordered_map<::std::string, ::std::string> key_values__arg); + + KVGetResponse(KVGetResponse&&) = default; + + KVGetResponse(const KVGetResponse&) = default; + + + KVGetResponse& operator=(KVGetResponse&&) = default; + + KVGetResponse& operator=(const KVGetResponse&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + public: + ::nebula::storage::cpp2::ResponseCommon result; + private: + std::unordered_map<::std::string, ::std::string> key_values; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool key_values; + } __isset = {}; + bool operator==(const KVGetResponse& rhs) const; +#ifndef SWIG + friend bool operator!=(const KVGetResponse& __x, const KVGetResponse& __y) { + return !(__x == __y); + } +#endif + bool operator<(const KVGetResponse& rhs) const; +#ifndef SWIG + friend bool operator>(const KVGetResponse& __x, const KVGetResponse& __y) { + return __y < __x; + } + friend bool operator<=(const KVGetResponse& __x, const KVGetResponse& __y) { + return !(__y < __x); + } + friend bool operator>=(const KVGetResponse& __x, const KVGetResponse& __y) { + return !(__x < __y); + } +#endif + template + FOLLY_ERASE ::apache::thrift::required_field_ref result_ref() const& { + return ::apache::thrift::required_field_ref{this->result}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref result_ref() const&& { + return ::apache::thrift::required_field_ref{std::move(this->result)}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref result_ref() & { + return ::apache::thrift::required_field_ref{this->result}; + } + + template + FOLLY_ERASE ::apache::thrift::required_field_ref result_ref() && { + return ::apache::thrift::required_field_ref{std::move(this->result)}; + } + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::field_ref key_values_ref() const& { + return {this->key_values, __isset.key_values}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref key_values_ref() const&& { + return {std::move(this->key_values), __isset.key_values}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref key_values_ref() & { + return {this->key_values, __isset.key_values}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref key_values_ref() && { + return {std::move(this->key_values), __isset.key_values}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + const ::nebula::storage::cpp2::ResponseCommon& get_result() const&; + ::nebula::storage::cpp2::ResponseCommon get_result() &&; + + template + ::nebula::storage::cpp2::ResponseCommon& set_result(T_KVGetResponse_result_struct_setter&& result_) { + result = std::forward(result_); + return result; + } + const std::unordered_map<::std::string, ::std::string>& get_key_values() const&; + std::unordered_map<::std::string, ::std::string> get_key_values() &&; + + template > + std::unordered_map<::std::string, ::std::string>& set_key_values(T_KVGetResponse_key_values_struct_setter&& key_values_) { + key_values = std::forward(key_values_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.key_values = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return key_values; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< KVGetResponse >; + friend void swap(KVGetResponse& a, KVGetResponse& b); +}; + +template +uint32_t KVGetResponse::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { +class KVPutRequest final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = KVPutRequest; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + KVPutRequest() : + space_id(0) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + KVPutRequest(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector> parts__arg); + + KVPutRequest(KVPutRequest&&) = default; + + KVPutRequest(const KVPutRequest&) = default; + + + KVPutRequest& operator=(KVPutRequest&&) = default; + + KVPutRequest& operator=(const KVPutRequest&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::GraphSpaceID space_id; + private: + std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector> parts; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool space_id; + bool parts; + } __isset = {}; + bool operator==(const KVPutRequest& rhs) const; +#ifndef SWIG + friend bool operator!=(const KVPutRequest& __x, const KVPutRequest& __y) { + return !(__x == __y); + } +#endif + bool operator<(const KVPutRequest& rhs) const; +#ifndef SWIG + friend bool operator>(const KVPutRequest& __x, const KVPutRequest& __y) { + return __y < __x; + } + friend bool operator<=(const KVPutRequest& __x, const KVPutRequest& __y) { + return !(__y < __x); + } + friend bool operator>=(const KVPutRequest& __x, const KVPutRequest& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const& { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const&& { + return {std::move(this->space_id), __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() & { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() && { + return {std::move(this->space_id), __isset.space_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template >> + FOLLY_ERASE ::apache::thrift::field_ref parts_ref() const& { + return {this->parts, __isset.parts}; + } + + template >> + FOLLY_ERASE ::apache::thrift::field_ref parts_ref() const&& { + return {std::move(this->parts), __isset.parts}; + } + + template >> + FOLLY_ERASE ::apache::thrift::field_ref parts_ref() & { + return {this->parts, __isset.parts}; + } + + template >> + FOLLY_ERASE ::apache::thrift::field_ref parts_ref() && { + return {std::move(this->parts), __isset.parts}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::GraphSpaceID get_space_id() const { + return space_id; + } + + ::nebula::cpp2::GraphSpaceID& set_space_id( ::nebula::cpp2::GraphSpaceID space_id_) { + space_id = space_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.space_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return space_id; + } + const std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector>& get_parts() const&; + std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector> get_parts() &&; + + template >> + std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector>& set_parts(T_KVPutRequest_parts_struct_setter&& parts_) { + parts = std::forward(parts_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.parts = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return parts; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< KVPutRequest >; + friend void swap(KVPutRequest& a, KVPutRequest& b); +}; + +template +uint32_t KVPutRequest::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { +class KVRemoveRequest final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = KVRemoveRequest; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + KVRemoveRequest() : + space_id(0) {} + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + KVRemoveRequest(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector<::std::string>> parts__arg); + + KVRemoveRequest(KVRemoveRequest&&) = default; + + KVRemoveRequest(const KVRemoveRequest&) = default; + + + KVRemoveRequest& operator=(KVRemoveRequest&&) = default; + + KVRemoveRequest& operator=(const KVRemoveRequest&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + private: + ::nebula::cpp2::GraphSpaceID space_id; + private: + std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector<::std::string>> parts; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool space_id; + bool parts; + } __isset = {}; + bool operator==(const KVRemoveRequest& rhs) const; +#ifndef SWIG + friend bool operator!=(const KVRemoveRequest& __x, const KVRemoveRequest& __y) { + return !(__x == __y); + } +#endif + bool operator<(const KVRemoveRequest& rhs) const; +#ifndef SWIG + friend bool operator>(const KVRemoveRequest& __x, const KVRemoveRequest& __y) { + return __y < __x; + } + friend bool operator<=(const KVRemoveRequest& __x, const KVRemoveRequest& __y) { + return !(__y < __x); + } + friend bool operator>=(const KVRemoveRequest& __x, const KVRemoveRequest& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const& { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const&& { + return {std::move(this->space_id), __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() & { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() && { + return {std::move(this->space_id), __isset.space_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template >> + FOLLY_ERASE ::apache::thrift::field_ref parts_ref() const& { + return {this->parts, __isset.parts}; + } + + template >> + FOLLY_ERASE ::apache::thrift::field_ref parts_ref() const&& { + return {std::move(this->parts), __isset.parts}; + } + + template >> + FOLLY_ERASE ::apache::thrift::field_ref parts_ref() & { + return {this->parts, __isset.parts}; + } + + template >> + FOLLY_ERASE ::apache::thrift::field_ref parts_ref() && { + return {std::move(this->parts), __isset.parts}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::GraphSpaceID get_space_id() const { + return space_id; + } + + ::nebula::cpp2::GraphSpaceID& set_space_id( ::nebula::cpp2::GraphSpaceID space_id_) { + space_id = space_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.space_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return space_id; + } + const std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector<::std::string>>& get_parts() const&; + std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector<::std::string>> get_parts() &&; + + template >> + std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector<::std::string>>& set_parts(T_KVRemoveRequest_parts_struct_setter&& parts_) { + parts = std::forward(parts_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.parts = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return parts; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< KVRemoveRequest >; + friend void swap(KVRemoveRequest& a, KVRemoveRequest& b); +}; + +template +uint32_t KVRemoveRequest::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { +class InternalTxnRequest final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = InternalTxnRequest; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + + InternalTxnRequest(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + InternalTxnRequest(apache::thrift::FragileConstructor, int64_t txn_id__arg, ::std::map< ::nebula::cpp2::PartitionID, int64_t> term_of_parts__arg, ::nebula::storage::cpp2::AddEdgesRequest add_edge_req__arg, ::nebula::storage::cpp2::UpdateEdgeRequest upd_edge_req__arg, std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector> edge_ver__arg); + + InternalTxnRequest(InternalTxnRequest&&) = default; + + InternalTxnRequest(const InternalTxnRequest&) = default; + + + InternalTxnRequest& operator=(InternalTxnRequest&&) = default; + + InternalTxnRequest& operator=(const InternalTxnRequest&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + + ~InternalTxnRequest(); + + private: + int64_t txn_id; + private: + ::std::map< ::nebula::cpp2::PartitionID, int64_t> term_of_parts; + private: + ::nebula::storage::cpp2::AddEdgesRequest add_edge_req; + private: + ::nebula::storage::cpp2::UpdateEdgeRequest upd_edge_req; + private: + std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector> edge_ver; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool txn_id; + bool term_of_parts; + bool add_edge_req; + bool upd_edge_req; + bool edge_ver; + } __isset = {}; + bool operator==(const InternalTxnRequest& rhs) const; +#ifndef SWIG + friend bool operator!=(const InternalTxnRequest& __x, const InternalTxnRequest& __y) { + return !(__x == __y); + } +#endif + bool operator<(const InternalTxnRequest& rhs) const; +#ifndef SWIG + friend bool operator>(const InternalTxnRequest& __x, const InternalTxnRequest& __y) { + return __y < __x; + } + friend bool operator<=(const InternalTxnRequest& __x, const InternalTxnRequest& __y) { + return !(__y < __x); + } + friend bool operator>=(const InternalTxnRequest& __x, const InternalTxnRequest& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref txn_id_ref() const& { + return {this->txn_id, __isset.txn_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref txn_id_ref() const&& { + return {std::move(this->txn_id), __isset.txn_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref txn_id_ref() & { + return {this->txn_id, __isset.txn_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref txn_id_ref() && { + return {std::move(this->txn_id), __isset.txn_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::field_ref term_of_parts_ref() const& { + return {this->term_of_parts, __isset.term_of_parts}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref term_of_parts_ref() const&& { + return {std::move(this->term_of_parts), __isset.term_of_parts}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref term_of_parts_ref() & { + return {this->term_of_parts, __isset.term_of_parts}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref term_of_parts_ref() && { + return {std::move(this->term_of_parts), __isset.term_of_parts}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::optional_field_ref add_edge_req_ref() const& { + return {this->add_edge_req, __isset.add_edge_req}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref add_edge_req_ref() const&& { + return {std::move(this->add_edge_req), __isset.add_edge_req}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref add_edge_req_ref() & { + return {this->add_edge_req, __isset.add_edge_req}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref add_edge_req_ref() && { + return {std::move(this->add_edge_req), __isset.add_edge_req}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::optional_field_ref upd_edge_req_ref() const& { + return {this->upd_edge_req, __isset.upd_edge_req}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref upd_edge_req_ref() const&& { + return {std::move(this->upd_edge_req), __isset.upd_edge_req}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref upd_edge_req_ref() & { + return {this->upd_edge_req, __isset.upd_edge_req}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref upd_edge_req_ref() && { + return {std::move(this->upd_edge_req), __isset.upd_edge_req}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template >> + FOLLY_ERASE ::apache::thrift::optional_field_ref edge_ver_ref() const& { + return {this->edge_ver, __isset.edge_ver}; + } + + template >> + FOLLY_ERASE ::apache::thrift::optional_field_ref edge_ver_ref() const&& { + return {std::move(this->edge_ver), __isset.edge_ver}; + } + + template >> + FOLLY_ERASE ::apache::thrift::optional_field_ref edge_ver_ref() & { + return {this->edge_ver, __isset.edge_ver}; + } + + template >> + FOLLY_ERASE ::apache::thrift::optional_field_ref edge_ver_ref() && { + return {std::move(this->edge_ver), __isset.edge_ver}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + int64_t get_txn_id() const { + return txn_id; + } + + int64_t& set_txn_id(int64_t txn_id_) { + txn_id = txn_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.txn_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return txn_id; + } + const ::std::map< ::nebula::cpp2::PartitionID, int64_t>& get_term_of_parts() const&; + ::std::map< ::nebula::cpp2::PartitionID, int64_t> get_term_of_parts() &&; + + template > + ::std::map< ::nebula::cpp2::PartitionID, int64_t>& set_term_of_parts(T_InternalTxnRequest_term_of_parts_struct_setter&& term_of_parts_) { + term_of_parts = std::forward(term_of_parts_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.term_of_parts = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return term_of_parts; + } + const ::nebula::storage::cpp2::AddEdgesRequest* get_add_edge_req() const&; + ::nebula::storage::cpp2::AddEdgesRequest* get_add_edge_req() &; + ::nebula::storage::cpp2::AddEdgesRequest* get_add_edge_req() && = delete; + + template + ::nebula::storage::cpp2::AddEdgesRequest& set_add_edge_req(T_InternalTxnRequest_add_edge_req_struct_setter&& add_edge_req_) { + add_edge_req = std::forward(add_edge_req_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.add_edge_req = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return add_edge_req; + } + const ::nebula::storage::cpp2::UpdateEdgeRequest* get_upd_edge_req() const&; + ::nebula::storage::cpp2::UpdateEdgeRequest* get_upd_edge_req() &; + ::nebula::storage::cpp2::UpdateEdgeRequest* get_upd_edge_req() && = delete; + + template + ::nebula::storage::cpp2::UpdateEdgeRequest& set_upd_edge_req(T_InternalTxnRequest_upd_edge_req_struct_setter&& upd_edge_req_) { + upd_edge_req = std::forward(upd_edge_req_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.upd_edge_req = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return upd_edge_req; + } + const std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector>* get_edge_ver() const&; + std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector>* get_edge_ver() &; + std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector>* get_edge_ver() && = delete; + + template >> + std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector>& set_edge_ver(T_InternalTxnRequest_edge_ver_struct_setter&& edge_ver_) { + edge_ver = std::forward(edge_ver_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.edge_ver = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return edge_ver; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< InternalTxnRequest >; + friend void swap(InternalTxnRequest& a, InternalTxnRequest& b); +}; + +template +uint32_t InternalTxnRequest::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { +class ChainAddEdgesRequest final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = ChainAddEdgesRequest; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + + ChainAddEdgesRequest(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + ChainAddEdgesRequest(apache::thrift::FragileConstructor, ::nebula::cpp2::GraphSpaceID space_id__arg, std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::storage::cpp2::NewEdge>> parts__arg, ::std::vector<::std::string> prop_names__arg, bool if_not_exists__arg, int64_t term__arg, int64_t edge_version__arg); + + ChainAddEdgesRequest(ChainAddEdgesRequest&&) = default; + + ChainAddEdgesRequest(const ChainAddEdgesRequest&) = default; + + + ChainAddEdgesRequest& operator=(ChainAddEdgesRequest&&) = default; + + ChainAddEdgesRequest& operator=(const ChainAddEdgesRequest&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + + ~ChainAddEdgesRequest(); + + private: + ::nebula::cpp2::GraphSpaceID space_id; + private: + std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::storage::cpp2::NewEdge>> parts; + private: + ::std::vector<::std::string> prop_names; + private: + bool if_not_exists; + private: + int64_t term; + private: + int64_t edge_version; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool space_id; + bool parts; + bool prop_names; + bool if_not_exists; + bool term; + bool edge_version; + } __isset = {}; + bool operator==(const ChainAddEdgesRequest& rhs) const; +#ifndef SWIG + friend bool operator!=(const ChainAddEdgesRequest& __x, const ChainAddEdgesRequest& __y) { + return !(__x == __y); + } +#endif + bool operator<(const ChainAddEdgesRequest& rhs) const; +#ifndef SWIG + friend bool operator>(const ChainAddEdgesRequest& __x, const ChainAddEdgesRequest& __y) { + return __y < __x; + } + friend bool operator<=(const ChainAddEdgesRequest& __x, const ChainAddEdgesRequest& __y) { + return !(__y < __x); + } + friend bool operator>=(const ChainAddEdgesRequest& __x, const ChainAddEdgesRequest& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const& { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const&& { + return {std::move(this->space_id), __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() & { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() && { + return {std::move(this->space_id), __isset.space_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template >> + FOLLY_ERASE ::apache::thrift::field_ref parts_ref() const& { + return {this->parts, __isset.parts}; + } + + template >> + FOLLY_ERASE ::apache::thrift::field_ref parts_ref() const&& { + return {std::move(this->parts), __isset.parts}; + } + + template >> + FOLLY_ERASE ::apache::thrift::field_ref parts_ref() & { + return {this->parts, __isset.parts}; + } + + template >> + FOLLY_ERASE ::apache::thrift::field_ref parts_ref() && { + return {std::move(this->parts), __isset.parts}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template > + FOLLY_ERASE ::apache::thrift::field_ref prop_names_ref() const& { + return {this->prop_names, __isset.prop_names}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref prop_names_ref() const&& { + return {std::move(this->prop_names), __isset.prop_names}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref prop_names_ref() & { + return {this->prop_names, __isset.prop_names}; + } + + template > + FOLLY_ERASE ::apache::thrift::field_ref prop_names_ref() && { + return {std::move(this->prop_names), __isset.prop_names}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref if_not_exists_ref() const& { + return {this->if_not_exists, __isset.if_not_exists}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref if_not_exists_ref() const&& { + return {std::move(this->if_not_exists), __isset.if_not_exists}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref if_not_exists_ref() & { + return {this->if_not_exists, __isset.if_not_exists}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref if_not_exists_ref() && { + return {std::move(this->if_not_exists), __isset.if_not_exists}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref term_ref() const& { + return {this->term, __isset.term}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref term_ref() const&& { + return {std::move(this->term), __isset.term}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref term_ref() & { + return {this->term, __isset.term}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref term_ref() && { + return {std::move(this->term), __isset.term}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::optional_field_ref edge_version_ref() const& { + return {this->edge_version, __isset.edge_version}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref edge_version_ref() const&& { + return {std::move(this->edge_version), __isset.edge_version}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref edge_version_ref() & { + return {this->edge_version, __isset.edge_version}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref edge_version_ref() && { + return {std::move(this->edge_version), __isset.edge_version}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + + ::nebula::cpp2::GraphSpaceID get_space_id() const { + return space_id; + } + + ::nebula::cpp2::GraphSpaceID& set_space_id( ::nebula::cpp2::GraphSpaceID space_id_) { + space_id = space_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.space_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return space_id; + } + const std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::storage::cpp2::NewEdge>>& get_parts() const&; + std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::storage::cpp2::NewEdge>> get_parts() &&; + + template >> + std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::storage::cpp2::NewEdge>>& set_parts(T_ChainAddEdgesRequest_parts_struct_setter&& parts_) { + parts = std::forward(parts_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.parts = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return parts; + } + const ::std::vector<::std::string>& get_prop_names() const&; + ::std::vector<::std::string> get_prop_names() &&; + + template > + ::std::vector<::std::string>& set_prop_names(T_ChainAddEdgesRequest_prop_names_struct_setter&& prop_names_) { + prop_names = std::forward(prop_names_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.prop_names = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return prop_names; + } + + bool get_if_not_exists() const { + return if_not_exists; + } + + bool& set_if_not_exists(bool if_not_exists_) { + if_not_exists = if_not_exists_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.if_not_exists = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return if_not_exists; + } + + int64_t get_term() const { + return term; + } + + int64_t& set_term(int64_t term_) { + term = term_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.term = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return term; + } + + const int64_t* get_edge_version() const& { + return edge_version_ref() ? std::addressof(edge_version) : nullptr; + } + + int64_t* get_edge_version() & { + return edge_version_ref() ? std::addressof(edge_version) : nullptr; + } + int64_t* get_edge_version() && = delete; + + int64_t& set_edge_version(int64_t edge_version_) { + edge_version = edge_version_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.edge_version = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return edge_version; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< ChainAddEdgesRequest >; + friend void swap(ChainAddEdgesRequest& a, ChainAddEdgesRequest& b); +}; + +template +uint32_t ChainAddEdgesRequest::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { +class ChainUpdateEdgeRequest final { + private: + friend struct ::apache::thrift::detail::st::struct_private_access; + + // used by a static_assert in the corresponding source + static constexpr bool __fbthrift_cpp2_gen_json = false; + static constexpr bool __fbthrift_cpp2_gen_nimble = false; + static constexpr bool __fbthrift_cpp2_gen_has_thrift_uri = false; + + public: + using __fbthrift_cpp2_type = ChainUpdateEdgeRequest; + static constexpr bool __fbthrift_cpp2_is_union = + false; + + + public: + + ChainUpdateEdgeRequest(); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + + // FragileConstructor for use in initialization lists only. + [[deprecated("This constructor is deprecated")]] + ChainUpdateEdgeRequest(apache::thrift::FragileConstructor, ::nebula::storage::cpp2::UpdateEdgeRequest update_edge_request__arg, int64_t term__arg, int64_t edge_version__arg, ::nebula::cpp2::GraphSpaceID space_id__arg, ::std::vector< ::nebula::cpp2::PartitionID> parts__arg); + + ChainUpdateEdgeRequest(ChainUpdateEdgeRequest&&) = default; + + ChainUpdateEdgeRequest(const ChainUpdateEdgeRequest&) = default; + + + ChainUpdateEdgeRequest& operator=(ChainUpdateEdgeRequest&&) = default; + + ChainUpdateEdgeRequest& operator=(const ChainUpdateEdgeRequest&) = default; +THRIFT_IGNORE_ISSET_USE_WARNING_END + void __clear(); + + ~ChainUpdateEdgeRequest(); + + private: + ::nebula::storage::cpp2::UpdateEdgeRequest update_edge_request; + private: + int64_t term; + private: + int64_t edge_version; + private: + ::nebula::cpp2::GraphSpaceID space_id; + public: + ::std::vector< ::nebula::cpp2::PartitionID> parts; + + public: + [[deprecated("__isset field is deprecated in Thrift struct. Use _ref() accessors instead.")]] + struct __isset { + bool update_edge_request; + bool term; + bool edge_version; + bool space_id; + } __isset = {}; + bool operator==(const ChainUpdateEdgeRequest& rhs) const; +#ifndef SWIG + friend bool operator!=(const ChainUpdateEdgeRequest& __x, const ChainUpdateEdgeRequest& __y) { + return !(__x == __y); + } +#endif + bool operator<(const ChainUpdateEdgeRequest& rhs) const; +#ifndef SWIG + friend bool operator>(const ChainUpdateEdgeRequest& __x, const ChainUpdateEdgeRequest& __y) { + return __y < __x; + } + friend bool operator<=(const ChainUpdateEdgeRequest& __x, const ChainUpdateEdgeRequest& __y) { + return !(__y < __x); + } + friend bool operator>=(const ChainUpdateEdgeRequest& __x, const ChainUpdateEdgeRequest& __y) { + return !(__x < __y); + } +#endif + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref update_edge_request_ref() const& { + return {this->update_edge_request, __isset.update_edge_request}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref update_edge_request_ref() const&& { + return {std::move(this->update_edge_request), __isset.update_edge_request}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref update_edge_request_ref() & { + return {this->update_edge_request, __isset.update_edge_request}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref update_edge_request_ref() && { + return {std::move(this->update_edge_request), __isset.update_edge_request}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref term_ref() const& { + return {this->term, __isset.term}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref term_ref() const&& { + return {std::move(this->term), __isset.term}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref term_ref() & { + return {this->term, __isset.term}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref term_ref() && { + return {std::move(this->term), __isset.term}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::optional_field_ref edge_version_ref() const& { + return {this->edge_version, __isset.edge_version}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref edge_version_ref() const&& { + return {std::move(this->edge_version), __isset.edge_version}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref edge_version_ref() & { + return {this->edge_version, __isset.edge_version}; + } + + template + FOLLY_ERASE ::apache::thrift::optional_field_ref edge_version_ref() && { + return {std::move(this->edge_version), __isset.edge_version}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const& { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() const&& { + return {std::move(this->space_id), __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() & { + return {this->space_id, __isset.space_id}; + } + + template + FOLLY_ERASE ::apache::thrift::field_ref space_id_ref() && { + return {std::move(this->space_id), __isset.space_id}; + } +THRIFT_IGNORE_ISSET_USE_WARNING_END + template > + FOLLY_ERASE ::apache::thrift::required_field_ref parts_ref() const& { + return ::apache::thrift::required_field_ref{this->parts}; + } + + template > + FOLLY_ERASE ::apache::thrift::required_field_ref parts_ref() const&& { + return ::apache::thrift::required_field_ref{std::move(this->parts)}; + } + + template > + FOLLY_ERASE ::apache::thrift::required_field_ref parts_ref() & { + return ::apache::thrift::required_field_ref{this->parts}; + } + + template > + FOLLY_ERASE ::apache::thrift::required_field_ref parts_ref() && { + return ::apache::thrift::required_field_ref{std::move(this->parts)}; + } + const ::nebula::storage::cpp2::UpdateEdgeRequest& get_update_edge_request() const&; + ::nebula::storage::cpp2::UpdateEdgeRequest get_update_edge_request() &&; + + template + ::nebula::storage::cpp2::UpdateEdgeRequest& set_update_edge_request(T_ChainUpdateEdgeRequest_update_edge_request_struct_setter&& update_edge_request_) { + update_edge_request = std::forward(update_edge_request_); +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.update_edge_request = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return update_edge_request; + } + + int64_t get_term() const { + return term; + } + + int64_t& set_term(int64_t term_) { + term = term_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.term = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return term; + } + + const int64_t* get_edge_version() const& { + return edge_version_ref() ? std::addressof(edge_version) : nullptr; + } + + int64_t* get_edge_version() & { + return edge_version_ref() ? std::addressof(edge_version) : nullptr; + } + int64_t* get_edge_version() && = delete; + + int64_t& set_edge_version(int64_t edge_version_) { + edge_version = edge_version_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.edge_version = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return edge_version; + } + + ::nebula::cpp2::GraphSpaceID get_space_id() const { + return space_id; + } + + ::nebula::cpp2::GraphSpaceID& set_space_id( ::nebula::cpp2::GraphSpaceID space_id_) { + space_id = space_id_; +THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + __isset.space_id = true; +THRIFT_IGNORE_ISSET_USE_WARNING_END + return space_id; + } + const ::std::vector< ::nebula::cpp2::PartitionID>& get_parts() const&; + ::std::vector< ::nebula::cpp2::PartitionID> get_parts() &&; + + template > + ::std::vector< ::nebula::cpp2::PartitionID>& set_parts(T_ChainUpdateEdgeRequest_parts_struct_setter&& parts_) { + parts = std::forward(parts_); + return parts; + } + + template + uint32_t read(Protocol_* iprot); + template + uint32_t serializedSize(Protocol_ const* prot_) const; + template + uint32_t serializedSizeZC(Protocol_ const* prot_) const; + template + uint32_t write(Protocol_* prot_) const; + + private: + template + void readNoXfer(Protocol_* iprot); + + friend class ::apache::thrift::Cpp2Ops< ChainUpdateEdgeRequest >; + friend void swap(ChainUpdateEdgeRequest& a, ChainUpdateEdgeRequest& b); +}; + +template +uint32_t ChainUpdateEdgeRequest::read(Protocol_* iprot) { + auto _xferStart = iprot->getCursorPosition(); + readNoXfer(iprot); + return iprot->getCursorPosition() - _xferStart; +} + +}}} // nebula::storage::cpp2 diff --git a/src/interface/gen-cpp2/storage_types.tcc b/src/interface/gen-cpp2/storage_types.tcc new file mode 100644 index 00000000..73e2eba2 --- /dev/null +++ b/src/interface/gen-cpp2/storage_types.tcc @@ -0,0 +1,13521 @@ +/** + * Autogenerated by Thrift for storage.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#pragma once + +#include "storage_types.h" + +#include + +namespace nebula { namespace storage { namespace cpp2 { + +}}} // nebula::storage::cpp2 +namespace std { + +} // std + +namespace nebula { namespace storage { namespace cpp2 { + +}}} // nebula::storage::cpp2 +namespace std { + +} // std + +namespace nebula { namespace storage { namespace cpp2 { + +}}} // nebula::storage::cpp2 +namespace std { + +} // std + +namespace nebula { namespace storage { namespace cpp2 { + +}}} // nebula::storage::cpp2 +namespace std { + +} // std + +namespace nebula { namespace storage { namespace cpp2 { + +}}} // nebula::storage::cpp2 +namespace std { + +} // std + + +namespace apache { +namespace thrift { +namespace detail { + +template <> +struct TccStructTraits<::nebula::storage::cpp2::RequestCommon> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::storage::cpp2::PartitionResult> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::storage::cpp2::ResponseCommon> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::storage::cpp2::StatProp> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::storage::cpp2::Expr> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::storage::cpp2::EdgeProp> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::storage::cpp2::VertexProp> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::storage::cpp2::OrderBy> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::storage::cpp2::TraverseSpec> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::storage::cpp2::GetNeighborsRequest> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::storage::cpp2::GetNeighborsResponse> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::storage::cpp2::ExecResponse> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::storage::cpp2::GetPropRequest> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::storage::cpp2::GetPropResponse> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::storage::cpp2::NewTag> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::storage::cpp2::NewVertex> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::storage::cpp2::EdgeKey> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::storage::cpp2::NewEdge> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::storage::cpp2::AddVerticesRequest> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::storage::cpp2::AddEdgesRequest> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::storage::cpp2::DeleteVerticesRequest> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::storage::cpp2::DeleteEdgesRequest> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::storage::cpp2::DelTags> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::storage::cpp2::DeleteTagsRequest> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::storage::cpp2::UpdateResponse> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::storage::cpp2::UpdatedProp> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::storage::cpp2::UpdateVertexRequest> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::storage::cpp2::UpdateEdgeRequest> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::storage::cpp2::GetUUIDReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::storage::cpp2::GetUUIDResp> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::storage::cpp2::LookupIndexResp> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::storage::cpp2::IndexColumnHint> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::storage::cpp2::IndexQueryContext> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::storage::cpp2::IndexSpec> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::storage::cpp2::LookupIndexRequest> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::storage::cpp2::LookupAndTraverseRequest> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::storage::cpp2::ScanVertexRequest> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::storage::cpp2::ScanVertexResponse> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::storage::cpp2::ScanEdgeRequest> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::storage::cpp2::ScanEdgeResponse> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::storage::cpp2::TaskPara> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::storage::cpp2::AddAdminTaskRequest> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::storage::cpp2::StopAdminTaskRequest> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::storage::cpp2::AdminExecResp> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::storage::cpp2::TransLeaderReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::storage::cpp2::AddPartReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::storage::cpp2::AddLearnerReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::storage::cpp2::RemovePartReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::storage::cpp2::MemberChangeReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::storage::cpp2::CatchUpDataReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::storage::cpp2::GetLeaderReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::storage::cpp2::CreateCPRequest> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::storage::cpp2::DropCPRequest> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::storage::cpp2::BlockingSignRequest> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::storage::cpp2::GetLeaderPartsResp> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::storage::cpp2::CheckPeersReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::storage::cpp2::RebuildIndexRequest> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::storage::cpp2::CreateCPResp> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::storage::cpp2::ListClusterInfoResp> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::storage::cpp2::ListClusterInfoReq> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::storage::cpp2::KVGetRequest> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::storage::cpp2::KVGetResponse> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::storage::cpp2::KVPutRequest> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::storage::cpp2::KVRemoveRequest> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::storage::cpp2::InternalTxnRequest> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::storage::cpp2::ChainAddEdgesRequest> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; +template <> +struct TccStructTraits<::nebula::storage::cpp2::ChainUpdateEdgeRequest> { + static void translateFieldName( + folly::StringPiece _fname, + int16_t& fid, + apache::thrift::protocol::TType& _ftype) noexcept; +}; + +} // namespace detail +} // namespace thrift +} // namespace apache + +namespace nebula { namespace storage { namespace cpp2 { + +template +void RequestCommon::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I64))) { + goto _loop; + } +_readField_session_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::SessionID>::readWithContext(*iprot, this->session_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.session_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_I64))) { + goto _loop; + } +_readField_plan_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::ExecutionPlanID>::readWithContext(*iprot, this->plan_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.plan_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_BOOL))) { + goto _loop; + } +_readField_profile_detail: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::readWithContext(*iprot, this->profile_detail, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.profile_detail = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I64))) { + goto _readField_session_id; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I64))) { + goto _readField_plan_id; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_BOOL))) { + goto _readField_profile_detail; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t RequestCommon::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("RequestCommon"); + if (this->session_id_ref().has_value()) { + xfer += prot_->serializedFieldSize("session_id", apache::thrift::protocol::T_I64, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::SessionID>::serializedSize(*prot_, this->session_id); + } + if (this->plan_id_ref().has_value()) { + xfer += prot_->serializedFieldSize("plan_id", apache::thrift::protocol::T_I64, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::ExecutionPlanID>::serializedSize(*prot_, this->plan_id); + } + if (this->profile_detail_ref().has_value()) { + xfer += prot_->serializedFieldSize("profile_detail", apache::thrift::protocol::T_BOOL, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::serializedSize(*prot_, this->profile_detail); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t RequestCommon::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("RequestCommon"); + if (this->session_id_ref().has_value()) { + xfer += prot_->serializedFieldSize("session_id", apache::thrift::protocol::T_I64, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::SessionID>::serializedSize(*prot_, this->session_id); + } + if (this->plan_id_ref().has_value()) { + xfer += prot_->serializedFieldSize("plan_id", apache::thrift::protocol::T_I64, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::ExecutionPlanID>::serializedSize(*prot_, this->plan_id); + } + if (this->profile_detail_ref().has_value()) { + xfer += prot_->serializedFieldSize("profile_detail", apache::thrift::protocol::T_BOOL, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::serializedSize(*prot_, this->profile_detail); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t RequestCommon::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("RequestCommon"); + if (this->session_id_ref().has_value()) { + xfer += prot_->writeFieldBegin("session_id", apache::thrift::protocol::T_I64, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::SessionID>::write(*prot_, this->session_id); + xfer += prot_->writeFieldEnd(); + } + if (this->plan_id_ref().has_value()) { + xfer += prot_->writeFieldBegin("plan_id", apache::thrift::protocol::T_I64, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::ExecutionPlanID>::write(*prot_, this->plan_id); + xfer += prot_->writeFieldEnd(); + } + if (this->profile_detail_ref().has_value()) { + xfer += prot_->writeFieldBegin("profile_detail", apache::thrift::protocol::T_BOOL, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::write(*prot_, this->profile_detail); + xfer += prot_->writeFieldEnd(); + } + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void RequestCommon::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t RequestCommon::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t RequestCommon::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t RequestCommon::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void RequestCommon::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t RequestCommon::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t RequestCommon::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t RequestCommon::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { + +template +void PartitionResult::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_code: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::readWithContext(*iprot, this->code, _readState); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_part_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::PartitionID>::readWithContext(*iprot, this->part_id, _readState); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_leader: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::readWithContext(*iprot, this->leader, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.leader = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_code; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_part_id; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_leader; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t PartitionResult::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("PartitionResult"); + xfer += prot_->serializedFieldSize("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::serializedSize(*prot_, this->code); + xfer += prot_->serializedFieldSize("part_id", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::PartitionID>::serializedSize(*prot_, this->part_id); + if (this->leader_ref().has_value()) { + xfer += prot_->serializedFieldSize("leader", apache::thrift::protocol::T_STRUCT, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->leader); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t PartitionResult::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("PartitionResult"); + xfer += prot_->serializedFieldSize("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::serializedSize(*prot_, this->code); + xfer += prot_->serializedFieldSize("part_id", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::PartitionID>::serializedSize(*prot_, this->part_id); + if (this->leader_ref().has_value()) { + xfer += prot_->serializedFieldSize("leader", apache::thrift::protocol::T_STRUCT, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->leader); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t PartitionResult::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("PartitionResult"); + xfer += prot_->writeFieldBegin("code", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::cpp2::ErrorCode>::write(*prot_, this->code); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("part_id", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::PartitionID>::write(*prot_, this->part_id); + xfer += prot_->writeFieldEnd(); + if (this->leader_ref().has_value()) { + xfer += prot_->writeFieldBegin("leader", apache::thrift::protocol::T_STRUCT, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::write(*prot_, this->leader); + xfer += prot_->writeFieldEnd(); + } + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void PartitionResult::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t PartitionResult::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t PartitionResult::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t PartitionResult::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void PartitionResult::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t PartitionResult::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t PartitionResult::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t PartitionResult::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { + +template +void ResponseCommon::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_failed_parts: + { + _readState.beforeSubobject(iprot); + this->failed_parts = ::std::vector< ::nebula::storage::cpp2::PartitionResult>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::storage::cpp2::PartitionResult>>::readWithContext(*iprot, this->failed_parts, _readState); + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_latency_in_us: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::readWithContext(*iprot, this->latency_in_us, _readState); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_MAP))) { + goto _loop; + } +_readField_latency_detail_us: + { + _readState.beforeSubobject(iprot); + this->latency_detail_us = ::std::map<::std::string, int32_t>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::string, ::apache::thrift::type_class::integral>, ::std::map<::std::string, int32_t>>::readWithContext(*iprot, this->latency_detail_us, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.latency_detail_us = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_failed_parts; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_latency_in_us; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_MAP))) { + goto _readField_latency_detail_us; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t ResponseCommon::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ResponseCommon"); + xfer += prot_->serializedFieldSize("failed_parts", apache::thrift::protocol::T_LIST, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::storage::cpp2::PartitionResult>>::serializedSize(*prot_, this->failed_parts); + xfer += prot_->serializedFieldSize("latency_in_us", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::serializedSize(*prot_, this->latency_in_us); + if (this->latency_detail_us_ref().has_value()) { + xfer += prot_->serializedFieldSize("latency_detail_us", apache::thrift::protocol::T_MAP, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::string, ::apache::thrift::type_class::integral>, ::std::map<::std::string, int32_t>>::serializedSize(*prot_, this->latency_detail_us); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ResponseCommon::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ResponseCommon"); + xfer += prot_->serializedFieldSize("failed_parts", apache::thrift::protocol::T_LIST, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::storage::cpp2::PartitionResult>>::serializedSize(*prot_, this->failed_parts); + xfer += prot_->serializedFieldSize("latency_in_us", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::serializedSize(*prot_, this->latency_in_us); + if (this->latency_detail_us_ref().has_value()) { + xfer += prot_->serializedFieldSize("latency_detail_us", apache::thrift::protocol::T_MAP, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::string, ::apache::thrift::type_class::integral>, ::std::map<::std::string, int32_t>>::serializedSize(*prot_, this->latency_detail_us); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ResponseCommon::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("ResponseCommon"); + xfer += prot_->writeFieldBegin("failed_parts", apache::thrift::protocol::T_LIST, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::storage::cpp2::PartitionResult>>::write(*prot_, this->failed_parts); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("latency_in_us", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::write(*prot_, this->latency_in_us); + xfer += prot_->writeFieldEnd(); + if (this->latency_detail_us_ref().has_value()) { + xfer += prot_->writeFieldBegin("latency_detail_us", apache::thrift::protocol::T_MAP, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::string, ::apache::thrift::type_class::integral>, ::std::map<::std::string, int32_t>>::write(*prot_, this->latency_detail_us); + xfer += prot_->writeFieldEnd(); + } + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void ResponseCommon::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t ResponseCommon::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t ResponseCommon::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t ResponseCommon::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void ResponseCommon::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t ResponseCommon::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t ResponseCommon::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t ResponseCommon::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { + +template +void StatProp::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_alias: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->alias, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.alias = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_prop: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->prop, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.prop = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_stat: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::storage::cpp2::StatType>::readWithContext(*iprot, this->stat, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.stat = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_alias; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_prop; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_stat; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t StatProp::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("StatProp"); + xfer += prot_->serializedFieldSize("alias", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->alias); + xfer += prot_->serializedFieldSize("prop", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->prop); + xfer += prot_->serializedFieldSize("stat", apache::thrift::protocol::T_I32, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::storage::cpp2::StatType>::serializedSize(*prot_, this->stat); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t StatProp::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("StatProp"); + xfer += prot_->serializedFieldSize("alias", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->alias); + xfer += prot_->serializedFieldSize("prop", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->prop); + xfer += prot_->serializedFieldSize("stat", apache::thrift::protocol::T_I32, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::storage::cpp2::StatType>::serializedSize(*prot_, this->stat); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t StatProp::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("StatProp"); + xfer += prot_->writeFieldBegin("alias", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->alias); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("prop", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->prop); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("stat", apache::thrift::protocol::T_I32, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::storage::cpp2::StatType>::write(*prot_, this->stat); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void StatProp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t StatProp::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t StatProp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t StatProp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void StatProp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t StatProp::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t StatProp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t StatProp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { + +template +void Expr::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_alias: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->alias, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.alias = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_expr: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->expr, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.expr = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_alias; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_expr; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t Expr::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("Expr"); + xfer += prot_->serializedFieldSize("alias", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->alias); + xfer += prot_->serializedFieldSize("expr", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->expr); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t Expr::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("Expr"); + xfer += prot_->serializedFieldSize("alias", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->alias); + xfer += prot_->serializedFieldSize("expr", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->expr); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t Expr::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("Expr"); + xfer += prot_->writeFieldBegin("alias", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->alias); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("expr", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->expr); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void Expr::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t Expr::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t Expr::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t Expr::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void Expr::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t Expr::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t Expr::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t Expr::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { + +template +void EdgeProp::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_type: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::EdgeType>::readWithContext(*iprot, this->type, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.type = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_props: + { + _readState.beforeSubobject(iprot); + this->props = ::std::vector<::std::string>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>, ::std::vector<::std::string>>::readWithContext(*iprot, this->props, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.props = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_type; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_props; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t EdgeProp::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("EdgeProp"); + xfer += prot_->serializedFieldSize("type", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::EdgeType>::serializedSize(*prot_, this->type); + xfer += prot_->serializedFieldSize("props", apache::thrift::protocol::T_LIST, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>, ::std::vector<::std::string>>::serializedSize(*prot_, this->props); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t EdgeProp::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("EdgeProp"); + xfer += prot_->serializedFieldSize("type", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::EdgeType>::serializedSize(*prot_, this->type); + xfer += prot_->serializedFieldSize("props", apache::thrift::protocol::T_LIST, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>, ::std::vector<::std::string>>::serializedSize(*prot_, this->props); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t EdgeProp::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("EdgeProp"); + xfer += prot_->writeFieldBegin("type", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::EdgeType>::write(*prot_, this->type); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("props", apache::thrift::protocol::T_LIST, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>, ::std::vector<::std::string>>::write(*prot_, this->props); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void EdgeProp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t EdgeProp::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t EdgeProp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t EdgeProp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void EdgeProp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t EdgeProp::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t EdgeProp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t EdgeProp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { + +template +void VertexProp::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_tag: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::TagID>::readWithContext(*iprot, this->tag, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.tag = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_props: + { + _readState.beforeSubobject(iprot); + this->props = ::std::vector<::std::string>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>, ::std::vector<::std::string>>::readWithContext(*iprot, this->props, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.props = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_tag; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_props; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t VertexProp::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("VertexProp"); + xfer += prot_->serializedFieldSize("tag", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::TagID>::serializedSize(*prot_, this->tag); + xfer += prot_->serializedFieldSize("props", apache::thrift::protocol::T_LIST, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>, ::std::vector<::std::string>>::serializedSize(*prot_, this->props); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t VertexProp::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("VertexProp"); + xfer += prot_->serializedFieldSize("tag", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::TagID>::serializedSize(*prot_, this->tag); + xfer += prot_->serializedFieldSize("props", apache::thrift::protocol::T_LIST, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>, ::std::vector<::std::string>>::serializedSize(*prot_, this->props); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t VertexProp::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("VertexProp"); + xfer += prot_->writeFieldBegin("tag", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::TagID>::write(*prot_, this->tag); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("props", apache::thrift::protocol::T_LIST, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>, ::std::vector<::std::string>>::write(*prot_, this->props); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void VertexProp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t VertexProp::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t VertexProp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t VertexProp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void VertexProp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t VertexProp::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t VertexProp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t VertexProp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { + +template +void OrderBy::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_prop: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->prop, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.prop = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_direction: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::storage::cpp2::OrderDirection>::readWithContext(*iprot, this->direction, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.direction = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_prop; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_direction; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t OrderBy::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("OrderBy"); + xfer += prot_->serializedFieldSize("prop", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->prop); + xfer += prot_->serializedFieldSize("direction", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::storage::cpp2::OrderDirection>::serializedSize(*prot_, this->direction); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t OrderBy::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("OrderBy"); + xfer += prot_->serializedFieldSize("prop", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->prop); + xfer += prot_->serializedFieldSize("direction", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::storage::cpp2::OrderDirection>::serializedSize(*prot_, this->direction); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t OrderBy::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("OrderBy"); + xfer += prot_->writeFieldBegin("prop", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->prop); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("direction", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::storage::cpp2::OrderDirection>::write(*prot_, this->direction); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void OrderBy::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t OrderBy::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t OrderBy::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t OrderBy::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void OrderBy::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t OrderBy::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t OrderBy::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t OrderBy::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { + +template +void TraverseSpec::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_edge_types: + { + _readState.beforeSubobject(iprot); + this->edge_types = ::std::vector< ::nebula::cpp2::EdgeType>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::integral>, ::std::vector< ::nebula::cpp2::EdgeType>>::readWithContext(*iprot, this->edge_types, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.edge_types = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_edge_direction: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::storage::cpp2::EdgeDirection>::readWithContext(*iprot, this->edge_direction, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.edge_direction = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_BOOL))) { + goto _loop; + } +_readField_dedup: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::readWithContext(*iprot, this->dedup, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.dedup = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 4, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_stat_props: + { + _readState.beforeSubobject(iprot); + this->stat_props = ::std::vector< ::nebula::storage::cpp2::StatProp>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::storage::cpp2::StatProp>>::readWithContext(*iprot, this->stat_props, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.stat_props = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 4, + 5, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_vertex_props: + { + _readState.beforeSubobject(iprot); + this->vertex_props = ::std::vector< ::nebula::storage::cpp2::VertexProp>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::storage::cpp2::VertexProp>>::readWithContext(*iprot, this->vertex_props, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.vertex_props = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 5, + 6, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_edge_props: + { + _readState.beforeSubobject(iprot); + this->edge_props = ::std::vector< ::nebula::storage::cpp2::EdgeProp>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::storage::cpp2::EdgeProp>>::readWithContext(*iprot, this->edge_props, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.edge_props = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 6, + 7, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_expressions: + { + _readState.beforeSubobject(iprot); + this->expressions = ::std::vector< ::nebula::storage::cpp2::Expr>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::storage::cpp2::Expr>>::readWithContext(*iprot, this->expressions, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.expressions = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 7, + 8, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_order_by: + { + _readState.beforeSubobject(iprot); + this->order_by = ::std::vector< ::nebula::storage::cpp2::OrderBy>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::storage::cpp2::OrderBy>>::readWithContext(*iprot, this->order_by, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.order_by = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 8, + 9, + apache::thrift::protocol::T_BOOL))) { + goto _loop; + } +_readField_random: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::readWithContext(*iprot, this->random, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.random = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 9, + 10, + apache::thrift::protocol::T_I64))) { + goto _loop; + } +_readField_limit: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::readWithContext(*iprot, this->limit, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.limit = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 10, + 11, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_filter: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->filter, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.filter = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 11, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_edge_types; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_edge_direction; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_BOOL))) { + goto _readField_dedup; + } else { + goto _skip; + } + } + case 4: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_stat_props; + } else { + goto _skip; + } + } + case 5: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_vertex_props; + } else { + goto _skip; + } + } + case 6: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_edge_props; + } else { + goto _skip; + } + } + case 7: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_expressions; + } else { + goto _skip; + } + } + case 8: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_order_by; + } else { + goto _skip; + } + } + case 9: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_BOOL))) { + goto _readField_random; + } else { + goto _skip; + } + } + case 10: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I64))) { + goto _readField_limit; + } else { + goto _skip; + } + } + case 11: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_filter; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t TraverseSpec::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("TraverseSpec"); + xfer += prot_->serializedFieldSize("edge_types", apache::thrift::protocol::T_LIST, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::integral>, ::std::vector< ::nebula::cpp2::EdgeType>>::serializedSize(*prot_, this->edge_types); + xfer += prot_->serializedFieldSize("edge_direction", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::storage::cpp2::EdgeDirection>::serializedSize(*prot_, this->edge_direction); + xfer += prot_->serializedFieldSize("dedup", apache::thrift::protocol::T_BOOL, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::serializedSize(*prot_, this->dedup); + if (this->stat_props_ref().has_value()) { + xfer += prot_->serializedFieldSize("stat_props", apache::thrift::protocol::T_LIST, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::storage::cpp2::StatProp>>::serializedSize(*prot_, this->stat_props); + } + if (this->vertex_props_ref().has_value()) { + xfer += prot_->serializedFieldSize("vertex_props", apache::thrift::protocol::T_LIST, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::storage::cpp2::VertexProp>>::serializedSize(*prot_, this->vertex_props); + } + if (this->edge_props_ref().has_value()) { + xfer += prot_->serializedFieldSize("edge_props", apache::thrift::protocol::T_LIST, 6); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::storage::cpp2::EdgeProp>>::serializedSize(*prot_, this->edge_props); + } + if (this->expressions_ref().has_value()) { + xfer += prot_->serializedFieldSize("expressions", apache::thrift::protocol::T_LIST, 7); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::storage::cpp2::Expr>>::serializedSize(*prot_, this->expressions); + } + if (this->order_by_ref().has_value()) { + xfer += prot_->serializedFieldSize("order_by", apache::thrift::protocol::T_LIST, 8); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::storage::cpp2::OrderBy>>::serializedSize(*prot_, this->order_by); + } + if (this->random_ref().has_value()) { + xfer += prot_->serializedFieldSize("random", apache::thrift::protocol::T_BOOL, 9); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::serializedSize(*prot_, this->random); + } + if (this->limit_ref().has_value()) { + xfer += prot_->serializedFieldSize("limit", apache::thrift::protocol::T_I64, 10); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::serializedSize(*prot_, this->limit); + } + if (this->filter_ref().has_value()) { + xfer += prot_->serializedFieldSize("filter", apache::thrift::protocol::T_STRING, 11); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->filter); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t TraverseSpec::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("TraverseSpec"); + xfer += prot_->serializedFieldSize("edge_types", apache::thrift::protocol::T_LIST, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::integral>, ::std::vector< ::nebula::cpp2::EdgeType>>::serializedSize(*prot_, this->edge_types); + xfer += prot_->serializedFieldSize("edge_direction", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::storage::cpp2::EdgeDirection>::serializedSize(*prot_, this->edge_direction); + xfer += prot_->serializedFieldSize("dedup", apache::thrift::protocol::T_BOOL, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::serializedSize(*prot_, this->dedup); + if (this->stat_props_ref().has_value()) { + xfer += prot_->serializedFieldSize("stat_props", apache::thrift::protocol::T_LIST, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::storage::cpp2::StatProp>>::serializedSize(*prot_, this->stat_props); + } + if (this->vertex_props_ref().has_value()) { + xfer += prot_->serializedFieldSize("vertex_props", apache::thrift::protocol::T_LIST, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::storage::cpp2::VertexProp>>::serializedSize(*prot_, this->vertex_props); + } + if (this->edge_props_ref().has_value()) { + xfer += prot_->serializedFieldSize("edge_props", apache::thrift::protocol::T_LIST, 6); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::storage::cpp2::EdgeProp>>::serializedSize(*prot_, this->edge_props); + } + if (this->expressions_ref().has_value()) { + xfer += prot_->serializedFieldSize("expressions", apache::thrift::protocol::T_LIST, 7); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::storage::cpp2::Expr>>::serializedSize(*prot_, this->expressions); + } + if (this->order_by_ref().has_value()) { + xfer += prot_->serializedFieldSize("order_by", apache::thrift::protocol::T_LIST, 8); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::storage::cpp2::OrderBy>>::serializedSize(*prot_, this->order_by); + } + if (this->random_ref().has_value()) { + xfer += prot_->serializedFieldSize("random", apache::thrift::protocol::T_BOOL, 9); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::serializedSize(*prot_, this->random); + } + if (this->limit_ref().has_value()) { + xfer += prot_->serializedFieldSize("limit", apache::thrift::protocol::T_I64, 10); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::serializedSize(*prot_, this->limit); + } + if (this->filter_ref().has_value()) { + xfer += prot_->serializedFieldSize("filter", apache::thrift::protocol::T_STRING, 11); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->filter); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t TraverseSpec::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("TraverseSpec"); + xfer += prot_->writeFieldBegin("edge_types", apache::thrift::protocol::T_LIST, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::integral>, ::std::vector< ::nebula::cpp2::EdgeType>>::write(*prot_, this->edge_types); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("edge_direction", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::storage::cpp2::EdgeDirection>::write(*prot_, this->edge_direction); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("dedup", apache::thrift::protocol::T_BOOL, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::write(*prot_, this->dedup); + xfer += prot_->writeFieldEnd(); + if (this->stat_props_ref().has_value()) { + xfer += prot_->writeFieldBegin("stat_props", apache::thrift::protocol::T_LIST, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::storage::cpp2::StatProp>>::write(*prot_, this->stat_props); + xfer += prot_->writeFieldEnd(); + } + if (this->vertex_props_ref().has_value()) { + xfer += prot_->writeFieldBegin("vertex_props", apache::thrift::protocol::T_LIST, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::storage::cpp2::VertexProp>>::write(*prot_, this->vertex_props); + xfer += prot_->writeFieldEnd(); + } + if (this->edge_props_ref().has_value()) { + xfer += prot_->writeFieldBegin("edge_props", apache::thrift::protocol::T_LIST, 6); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::storage::cpp2::EdgeProp>>::write(*prot_, this->edge_props); + xfer += prot_->writeFieldEnd(); + } + if (this->expressions_ref().has_value()) { + xfer += prot_->writeFieldBegin("expressions", apache::thrift::protocol::T_LIST, 7); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::storage::cpp2::Expr>>::write(*prot_, this->expressions); + xfer += prot_->writeFieldEnd(); + } + if (this->order_by_ref().has_value()) { + xfer += prot_->writeFieldBegin("order_by", apache::thrift::protocol::T_LIST, 8); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::storage::cpp2::OrderBy>>::write(*prot_, this->order_by); + xfer += prot_->writeFieldEnd(); + } + if (this->random_ref().has_value()) { + xfer += prot_->writeFieldBegin("random", apache::thrift::protocol::T_BOOL, 9); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::write(*prot_, this->random); + xfer += prot_->writeFieldEnd(); + } + if (this->limit_ref().has_value()) { + xfer += prot_->writeFieldBegin("limit", apache::thrift::protocol::T_I64, 10); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::write(*prot_, this->limit); + xfer += prot_->writeFieldEnd(); + } + if (this->filter_ref().has_value()) { + xfer += prot_->writeFieldBegin("filter", apache::thrift::protocol::T_STRING, 11); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->filter); + xfer += prot_->writeFieldEnd(); + } + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void TraverseSpec::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t TraverseSpec::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t TraverseSpec::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t TraverseSpec::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void TraverseSpec::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t TraverseSpec::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t TraverseSpec::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t TraverseSpec::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { + +template +void GetNeighborsRequest::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_space_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::readWithContext(*iprot, this->space_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.space_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_column_names: + { + _readState.beforeSubobject(iprot); + this->column_names = ::std::vector<::std::string>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>, ::std::vector<::std::string>>::readWithContext(*iprot, this->column_names, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.column_names = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_MAP))) { + goto _loop; + } +_readField_parts: + { + _readState.beforeSubobject(iprot); + this->parts = std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>>, std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector>>::readWithContext(*iprot, this->parts, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.parts = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 4, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_traverse_spec: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::TraverseSpec>::readWithContext(*iprot, this->traverse_spec, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.traverse_spec = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 4, + 5, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_common: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::RequestCommon>::readWithContext(*iprot, this->common, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.common = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 5, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_space_id; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_column_names; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_MAP))) { + goto _readField_parts; + } else { + goto _skip; + } + } + case 4: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_traverse_spec; + } else { + goto _skip; + } + } + case 5: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_common; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t GetNeighborsRequest::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("GetNeighborsRequest"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("column_names", apache::thrift::protocol::T_LIST, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>, ::std::vector<::std::string>>::serializedSize(*prot_, this->column_names); + xfer += prot_->serializedFieldSize("parts", apache::thrift::protocol::T_MAP, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>>, std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector>>::serializedSize(*prot_, this->parts); + xfer += prot_->serializedFieldSize("traverse_spec", apache::thrift::protocol::T_STRUCT, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::TraverseSpec>::serializedSize(*prot_, this->traverse_spec); + if (this->common_ref().has_value()) { + xfer += prot_->serializedFieldSize("common", apache::thrift::protocol::T_STRUCT, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::RequestCommon>::serializedSize(*prot_, this->common); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t GetNeighborsRequest::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("GetNeighborsRequest"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("column_names", apache::thrift::protocol::T_LIST, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>, ::std::vector<::std::string>>::serializedSize(*prot_, this->column_names); + xfer += prot_->serializedFieldSize("parts", apache::thrift::protocol::T_MAP, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>>, std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector>>::serializedSize(*prot_, this->parts); + xfer += prot_->serializedFieldSize("traverse_spec", apache::thrift::protocol::T_STRUCT, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::TraverseSpec>::serializedSize(*prot_, this->traverse_spec); + if (this->common_ref().has_value()) { + xfer += prot_->serializedFieldSize("common", apache::thrift::protocol::T_STRUCT, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::RequestCommon>::serializedSize(*prot_, this->common); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t GetNeighborsRequest::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("GetNeighborsRequest"); + xfer += prot_->writeFieldBegin("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::write(*prot_, this->space_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("column_names", apache::thrift::protocol::T_LIST, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>, ::std::vector<::std::string>>::write(*prot_, this->column_names); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("parts", apache::thrift::protocol::T_MAP, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>>, std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector>>::write(*prot_, this->parts); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("traverse_spec", apache::thrift::protocol::T_STRUCT, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::TraverseSpec>::write(*prot_, this->traverse_spec); + xfer += prot_->writeFieldEnd(); + if (this->common_ref().has_value()) { + xfer += prot_->writeFieldBegin("common", apache::thrift::protocol::T_STRUCT, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::RequestCommon>::write(*prot_, this->common); + xfer += prot_->writeFieldEnd(); + } + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void GetNeighborsRequest::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t GetNeighborsRequest::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t GetNeighborsRequest::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t GetNeighborsRequest::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void GetNeighborsRequest::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t GetNeighborsRequest::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t GetNeighborsRequest::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t GetNeighborsRequest::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { + +template +void GetNeighborsResponse::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_result: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::ResponseCommon>::readWithContext(*iprot, this->result, _readState); + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_vertices: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::DataSet>::readWithContext(*iprot, this->vertices, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.vertices = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_result; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_vertices; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t GetNeighborsResponse::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("GetNeighborsResponse"); + xfer += prot_->serializedFieldSize("result", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::ResponseCommon>::serializedSize(*prot_, this->result); + if (this->vertices_ref().has_value()) { + xfer += prot_->serializedFieldSize("vertices", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::DataSet>::serializedSize(*prot_, this->vertices); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t GetNeighborsResponse::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("GetNeighborsResponse"); + xfer += prot_->serializedFieldSize("result", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::ResponseCommon>::serializedSize(*prot_, this->result); + if (this->vertices_ref().has_value()) { + xfer += prot_->serializedFieldSize("vertices", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::DataSet>::serializedSize(*prot_, this->vertices); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t GetNeighborsResponse::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("GetNeighborsResponse"); + xfer += prot_->writeFieldBegin("result", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::ResponseCommon>::write(*prot_, this->result); + xfer += prot_->writeFieldEnd(); + if (this->vertices_ref().has_value()) { + xfer += prot_->writeFieldBegin("vertices", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::DataSet>::write(*prot_, this->vertices); + xfer += prot_->writeFieldEnd(); + } + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void GetNeighborsResponse::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t GetNeighborsResponse::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t GetNeighborsResponse::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t GetNeighborsResponse::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void GetNeighborsResponse::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t GetNeighborsResponse::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t GetNeighborsResponse::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t GetNeighborsResponse::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { + +template +void ExecResponse::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_result: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::ResponseCommon>::readWithContext(*iprot, this->result, _readState); + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_result; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t ExecResponse::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ExecResponse"); + xfer += prot_->serializedFieldSize("result", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::ResponseCommon>::serializedSize(*prot_, this->result); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ExecResponse::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ExecResponse"); + xfer += prot_->serializedFieldSize("result", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::ResponseCommon>::serializedSize(*prot_, this->result); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ExecResponse::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("ExecResponse"); + xfer += prot_->writeFieldBegin("result", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::ResponseCommon>::write(*prot_, this->result); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void ExecResponse::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t ExecResponse::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t ExecResponse::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t ExecResponse::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void ExecResponse::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t ExecResponse::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t ExecResponse::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t ExecResponse::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { + +template +void GetPropRequest::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_space_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::readWithContext(*iprot, this->space_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.space_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_MAP))) { + goto _loop; + } +_readField_parts: + { + _readState.beforeSubobject(iprot); + this->parts = std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>>, std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector>>::readWithContext(*iprot, this->parts, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.parts = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_vertex_props: + { + _readState.beforeSubobject(iprot); + this->vertex_props = ::std::vector< ::nebula::storage::cpp2::VertexProp>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::storage::cpp2::VertexProp>>::readWithContext(*iprot, this->vertex_props, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.vertex_props = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 4, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_edge_props: + { + _readState.beforeSubobject(iprot); + this->edge_props = ::std::vector< ::nebula::storage::cpp2::EdgeProp>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::storage::cpp2::EdgeProp>>::readWithContext(*iprot, this->edge_props, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.edge_props = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 4, + 5, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_expressions: + { + _readState.beforeSubobject(iprot); + this->expressions = ::std::vector< ::nebula::storage::cpp2::Expr>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::storage::cpp2::Expr>>::readWithContext(*iprot, this->expressions, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.expressions = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 5, + 6, + apache::thrift::protocol::T_BOOL))) { + goto _loop; + } +_readField_dedup: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::readWithContext(*iprot, this->dedup, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.dedup = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 6, + 7, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_order_by: + { + _readState.beforeSubobject(iprot); + this->order_by = ::std::vector< ::nebula::storage::cpp2::OrderBy>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::storage::cpp2::OrderBy>>::readWithContext(*iprot, this->order_by, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.order_by = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 7, + 8, + apache::thrift::protocol::T_I64))) { + goto _loop; + } +_readField_limit: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::readWithContext(*iprot, this->limit, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.limit = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 8, + 9, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_filter: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->filter, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.filter = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 9, + 10, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_common: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::RequestCommon>::readWithContext(*iprot, this->common, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.common = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 10, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_space_id; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_MAP))) { + goto _readField_parts; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_vertex_props; + } else { + goto _skip; + } + } + case 4: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_edge_props; + } else { + goto _skip; + } + } + case 5: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_expressions; + } else { + goto _skip; + } + } + case 6: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_BOOL))) { + goto _readField_dedup; + } else { + goto _skip; + } + } + case 7: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_order_by; + } else { + goto _skip; + } + } + case 8: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I64))) { + goto _readField_limit; + } else { + goto _skip; + } + } + case 9: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_filter; + } else { + goto _skip; + } + } + case 10: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_common; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t GetPropRequest::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("GetPropRequest"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("parts", apache::thrift::protocol::T_MAP, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>>, std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector>>::serializedSize(*prot_, this->parts); + if (this->vertex_props_ref().has_value()) { + xfer += prot_->serializedFieldSize("vertex_props", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::storage::cpp2::VertexProp>>::serializedSize(*prot_, this->vertex_props); + } + if (this->edge_props_ref().has_value()) { + xfer += prot_->serializedFieldSize("edge_props", apache::thrift::protocol::T_LIST, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::storage::cpp2::EdgeProp>>::serializedSize(*prot_, this->edge_props); + } + if (this->expressions_ref().has_value()) { + xfer += prot_->serializedFieldSize("expressions", apache::thrift::protocol::T_LIST, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::storage::cpp2::Expr>>::serializedSize(*prot_, this->expressions); + } + xfer += prot_->serializedFieldSize("dedup", apache::thrift::protocol::T_BOOL, 6); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::serializedSize(*prot_, this->dedup); + if (this->order_by_ref().has_value()) { + xfer += prot_->serializedFieldSize("order_by", apache::thrift::protocol::T_LIST, 7); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::storage::cpp2::OrderBy>>::serializedSize(*prot_, this->order_by); + } + if (this->limit_ref().has_value()) { + xfer += prot_->serializedFieldSize("limit", apache::thrift::protocol::T_I64, 8); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::serializedSize(*prot_, this->limit); + } + if (this->filter_ref().has_value()) { + xfer += prot_->serializedFieldSize("filter", apache::thrift::protocol::T_STRING, 9); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->filter); + } + if (this->common_ref().has_value()) { + xfer += prot_->serializedFieldSize("common", apache::thrift::protocol::T_STRUCT, 10); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::RequestCommon>::serializedSize(*prot_, this->common); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t GetPropRequest::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("GetPropRequest"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("parts", apache::thrift::protocol::T_MAP, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>>, std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector>>::serializedSize(*prot_, this->parts); + if (this->vertex_props_ref().has_value()) { + xfer += prot_->serializedFieldSize("vertex_props", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::storage::cpp2::VertexProp>>::serializedSize(*prot_, this->vertex_props); + } + if (this->edge_props_ref().has_value()) { + xfer += prot_->serializedFieldSize("edge_props", apache::thrift::protocol::T_LIST, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::storage::cpp2::EdgeProp>>::serializedSize(*prot_, this->edge_props); + } + if (this->expressions_ref().has_value()) { + xfer += prot_->serializedFieldSize("expressions", apache::thrift::protocol::T_LIST, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::storage::cpp2::Expr>>::serializedSize(*prot_, this->expressions); + } + xfer += prot_->serializedFieldSize("dedup", apache::thrift::protocol::T_BOOL, 6); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::serializedSize(*prot_, this->dedup); + if (this->order_by_ref().has_value()) { + xfer += prot_->serializedFieldSize("order_by", apache::thrift::protocol::T_LIST, 7); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::storage::cpp2::OrderBy>>::serializedSize(*prot_, this->order_by); + } + if (this->limit_ref().has_value()) { + xfer += prot_->serializedFieldSize("limit", apache::thrift::protocol::T_I64, 8); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::serializedSize(*prot_, this->limit); + } + if (this->filter_ref().has_value()) { + xfer += prot_->serializedFieldSize("filter", apache::thrift::protocol::T_STRING, 9); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->filter); + } + if (this->common_ref().has_value()) { + xfer += prot_->serializedFieldSize("common", apache::thrift::protocol::T_STRUCT, 10); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::RequestCommon>::serializedSize(*prot_, this->common); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t GetPropRequest::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("GetPropRequest"); + xfer += prot_->writeFieldBegin("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::write(*prot_, this->space_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("parts", apache::thrift::protocol::T_MAP, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>>, std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector>>::write(*prot_, this->parts); + xfer += prot_->writeFieldEnd(); + if (this->vertex_props_ref().has_value()) { + xfer += prot_->writeFieldBegin("vertex_props", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::storage::cpp2::VertexProp>>::write(*prot_, this->vertex_props); + xfer += prot_->writeFieldEnd(); + } + if (this->edge_props_ref().has_value()) { + xfer += prot_->writeFieldBegin("edge_props", apache::thrift::protocol::T_LIST, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::storage::cpp2::EdgeProp>>::write(*prot_, this->edge_props); + xfer += prot_->writeFieldEnd(); + } + if (this->expressions_ref().has_value()) { + xfer += prot_->writeFieldBegin("expressions", apache::thrift::protocol::T_LIST, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::storage::cpp2::Expr>>::write(*prot_, this->expressions); + xfer += prot_->writeFieldEnd(); + } + xfer += prot_->writeFieldBegin("dedup", apache::thrift::protocol::T_BOOL, 6); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::write(*prot_, this->dedup); + xfer += prot_->writeFieldEnd(); + if (this->order_by_ref().has_value()) { + xfer += prot_->writeFieldBegin("order_by", apache::thrift::protocol::T_LIST, 7); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::storage::cpp2::OrderBy>>::write(*prot_, this->order_by); + xfer += prot_->writeFieldEnd(); + } + if (this->limit_ref().has_value()) { + xfer += prot_->writeFieldBegin("limit", apache::thrift::protocol::T_I64, 8); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::write(*prot_, this->limit); + xfer += prot_->writeFieldEnd(); + } + if (this->filter_ref().has_value()) { + xfer += prot_->writeFieldBegin("filter", apache::thrift::protocol::T_STRING, 9); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->filter); + xfer += prot_->writeFieldEnd(); + } + if (this->common_ref().has_value()) { + xfer += prot_->writeFieldBegin("common", apache::thrift::protocol::T_STRUCT, 10); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::RequestCommon>::write(*prot_, this->common); + xfer += prot_->writeFieldEnd(); + } + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void GetPropRequest::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t GetPropRequest::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t GetPropRequest::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t GetPropRequest::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void GetPropRequest::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t GetPropRequest::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t GetPropRequest::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t GetPropRequest::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { + +template +void GetPropResponse::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_result: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::ResponseCommon>::readWithContext(*iprot, this->result, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.result = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_props: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::DataSet>::readWithContext(*iprot, this->props, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.props = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_result; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_props; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t GetPropResponse::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("GetPropResponse"); + xfer += prot_->serializedFieldSize("result", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::ResponseCommon>::serializedSize(*prot_, this->result); + if (this->props_ref().has_value()) { + xfer += prot_->serializedFieldSize("props", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::DataSet>::serializedSize(*prot_, this->props); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t GetPropResponse::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("GetPropResponse"); + xfer += prot_->serializedFieldSize("result", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::ResponseCommon>::serializedSize(*prot_, this->result); + if (this->props_ref().has_value()) { + xfer += prot_->serializedFieldSize("props", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::DataSet>::serializedSize(*prot_, this->props); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t GetPropResponse::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("GetPropResponse"); + xfer += prot_->writeFieldBegin("result", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::ResponseCommon>::write(*prot_, this->result); + xfer += prot_->writeFieldEnd(); + if (this->props_ref().has_value()) { + xfer += prot_->writeFieldBegin("props", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::DataSet>::write(*prot_, this->props); + xfer += prot_->writeFieldEnd(); + } + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void GetPropResponse::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t GetPropResponse::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t GetPropResponse::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t GetPropResponse::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void GetPropResponse::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t GetPropResponse::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t GetPropResponse::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t GetPropResponse::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { + +template +void NewTag::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_tag_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::TagID>::readWithContext(*iprot, this->tag_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.tag_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_props: + { + _readState.beforeSubobject(iprot); + this->props = ::std::vector(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::variant>, ::std::vector>::readWithContext(*iprot, this->props, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.props = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_tag_id; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_props; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t NewTag::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("NewTag"); + xfer += prot_->serializedFieldSize("tag_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::TagID>::serializedSize(*prot_, this->tag_id); + xfer += prot_->serializedFieldSize("props", apache::thrift::protocol::T_LIST, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::variant>, ::std::vector>::serializedSize(*prot_, this->props); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t NewTag::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("NewTag"); + xfer += prot_->serializedFieldSize("tag_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::TagID>::serializedSize(*prot_, this->tag_id); + xfer += prot_->serializedFieldSize("props", apache::thrift::protocol::T_LIST, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::variant>, ::std::vector>::serializedSize(*prot_, this->props); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t NewTag::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("NewTag"); + xfer += prot_->writeFieldBegin("tag_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::TagID>::write(*prot_, this->tag_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("props", apache::thrift::protocol::T_LIST, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::variant>, ::std::vector>::write(*prot_, this->props); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void NewTag::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t NewTag::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t NewTag::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t NewTag::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void NewTag::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t NewTag::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t NewTag::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t NewTag::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { + +template +void NewVertex::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_id: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::variant, nebula::Value>::readWithContext(*iprot, this->id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_tags: + { + _readState.beforeSubobject(iprot); + this->tags = ::std::vector< ::nebula::storage::cpp2::NewTag>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::storage::cpp2::NewTag>>::readWithContext(*iprot, this->tags, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.tags = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_id; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_tags; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t NewVertex::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("NewVertex"); + xfer += prot_->serializedFieldSize("id", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::variant, nebula::Value>::serializedSize(*prot_, this->id); + xfer += prot_->serializedFieldSize("tags", apache::thrift::protocol::T_LIST, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::storage::cpp2::NewTag>>::serializedSize(*prot_, this->tags); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t NewVertex::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("NewVertex"); + xfer += prot_->serializedFieldSize("id", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::variant, nebula::Value>::serializedSize(*prot_, this->id); + xfer += prot_->serializedFieldSize("tags", apache::thrift::protocol::T_LIST, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::storage::cpp2::NewTag>>::serializedSize(*prot_, this->tags); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t NewVertex::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("NewVertex"); + xfer += prot_->writeFieldBegin("id", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::variant, nebula::Value>::write(*prot_, this->id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("tags", apache::thrift::protocol::T_LIST, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::storage::cpp2::NewTag>>::write(*prot_, this->tags); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void NewVertex::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t NewVertex::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t NewVertex::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t NewVertex::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void NewVertex::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t NewVertex::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t NewVertex::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t NewVertex::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { + +template +void EdgeKey::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_src: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::variant, nebula::Value>::readWithContext(*iprot, this->src, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.src = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_edge_type: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::EdgeType>::readWithContext(*iprot, this->edge_type, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.edge_type = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_I64))) { + goto _loop; + } +_readField_ranking: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::EdgeRanking>::readWithContext(*iprot, this->ranking, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.ranking = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 4, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_dst: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::variant, nebula::Value>::readWithContext(*iprot, this->dst, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.dst = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 4, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_src; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_edge_type; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I64))) { + goto _readField_ranking; + } else { + goto _skip; + } + } + case 4: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_dst; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t EdgeKey::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("EdgeKey"); + xfer += prot_->serializedFieldSize("src", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::variant, nebula::Value>::serializedSize(*prot_, this->src); + xfer += prot_->serializedFieldSize("edge_type", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::EdgeType>::serializedSize(*prot_, this->edge_type); + xfer += prot_->serializedFieldSize("ranking", apache::thrift::protocol::T_I64, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::EdgeRanking>::serializedSize(*prot_, this->ranking); + xfer += prot_->serializedFieldSize("dst", apache::thrift::protocol::T_STRUCT, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::variant, nebula::Value>::serializedSize(*prot_, this->dst); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t EdgeKey::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("EdgeKey"); + xfer += prot_->serializedFieldSize("src", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::variant, nebula::Value>::serializedSize(*prot_, this->src); + xfer += prot_->serializedFieldSize("edge_type", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::EdgeType>::serializedSize(*prot_, this->edge_type); + xfer += prot_->serializedFieldSize("ranking", apache::thrift::protocol::T_I64, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::EdgeRanking>::serializedSize(*prot_, this->ranking); + xfer += prot_->serializedFieldSize("dst", apache::thrift::protocol::T_STRUCT, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::variant, nebula::Value>::serializedSize(*prot_, this->dst); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t EdgeKey::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("EdgeKey"); + xfer += prot_->writeFieldBegin("src", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::variant, nebula::Value>::write(*prot_, this->src); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("edge_type", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::EdgeType>::write(*prot_, this->edge_type); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("ranking", apache::thrift::protocol::T_I64, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::EdgeRanking>::write(*prot_, this->ranking); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("dst", apache::thrift::protocol::T_STRUCT, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::variant, nebula::Value>::write(*prot_, this->dst); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void EdgeKey::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t EdgeKey::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t EdgeKey::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t EdgeKey::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void EdgeKey::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t EdgeKey::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t EdgeKey::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t EdgeKey::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { + +template +void NewEdge::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_key: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::EdgeKey>::readWithContext(*iprot, this->key, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.key = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_props: + { + _readState.beforeSubobject(iprot); + this->props = ::std::vector(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::variant>, ::std::vector>::readWithContext(*iprot, this->props, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.props = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_key; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_props; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t NewEdge::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("NewEdge"); + xfer += prot_->serializedFieldSize("key", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::EdgeKey>::serializedSize(*prot_, this->key); + xfer += prot_->serializedFieldSize("props", apache::thrift::protocol::T_LIST, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::variant>, ::std::vector>::serializedSize(*prot_, this->props); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t NewEdge::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("NewEdge"); + xfer += prot_->serializedFieldSize("key", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::EdgeKey>::serializedSize(*prot_, this->key); + xfer += prot_->serializedFieldSize("props", apache::thrift::protocol::T_LIST, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::variant>, ::std::vector>::serializedSize(*prot_, this->props); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t NewEdge::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("NewEdge"); + xfer += prot_->writeFieldBegin("key", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::EdgeKey>::write(*prot_, this->key); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("props", apache::thrift::protocol::T_LIST, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::variant>, ::std::vector>::write(*prot_, this->props); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void NewEdge::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t NewEdge::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t NewEdge::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t NewEdge::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void NewEdge::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t NewEdge::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t NewEdge::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t NewEdge::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { + +template +void AddVerticesRequest::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_space_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::readWithContext(*iprot, this->space_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.space_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_MAP))) { + goto _loop; + } +_readField_parts: + { + _readState.beforeSubobject(iprot); + this->parts = std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::storage::cpp2::NewVertex>>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>>, std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::storage::cpp2::NewVertex>>>::readWithContext(*iprot, this->parts, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.parts = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_MAP))) { + goto _loop; + } +_readField_prop_names: + { + _readState.beforeSubobject(iprot); + this->prop_names = std::unordered_map< ::nebula::cpp2::TagID, ::std::vector<::std::string>>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>>, std::unordered_map< ::nebula::cpp2::TagID, ::std::vector<::std::string>>>::readWithContext(*iprot, this->prop_names, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.prop_names = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 4, + apache::thrift::protocol::T_BOOL))) { + goto _loop; + } +_readField_if_not_exists: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::readWithContext(*iprot, this->if_not_exists, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.if_not_exists = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 4, + 5, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_common: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::RequestCommon>::readWithContext(*iprot, this->common, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.common = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 5, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_space_id; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_MAP))) { + goto _readField_parts; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_MAP))) { + goto _readField_prop_names; + } else { + goto _skip; + } + } + case 4: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_BOOL))) { + goto _readField_if_not_exists; + } else { + goto _skip; + } + } + case 5: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_common; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t AddVerticesRequest::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("AddVerticesRequest"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("parts", apache::thrift::protocol::T_MAP, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>>, std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::storage::cpp2::NewVertex>>>::serializedSize(*prot_, this->parts); + xfer += prot_->serializedFieldSize("prop_names", apache::thrift::protocol::T_MAP, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>>, std::unordered_map< ::nebula::cpp2::TagID, ::std::vector<::std::string>>>::serializedSize(*prot_, this->prop_names); + xfer += prot_->serializedFieldSize("if_not_exists", apache::thrift::protocol::T_BOOL, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::serializedSize(*prot_, this->if_not_exists); + if (this->common_ref().has_value()) { + xfer += prot_->serializedFieldSize("common", apache::thrift::protocol::T_STRUCT, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::RequestCommon>::serializedSize(*prot_, this->common); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t AddVerticesRequest::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("AddVerticesRequest"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("parts", apache::thrift::protocol::T_MAP, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>>, std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::storage::cpp2::NewVertex>>>::serializedSize(*prot_, this->parts); + xfer += prot_->serializedFieldSize("prop_names", apache::thrift::protocol::T_MAP, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>>, std::unordered_map< ::nebula::cpp2::TagID, ::std::vector<::std::string>>>::serializedSize(*prot_, this->prop_names); + xfer += prot_->serializedFieldSize("if_not_exists", apache::thrift::protocol::T_BOOL, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::serializedSize(*prot_, this->if_not_exists); + if (this->common_ref().has_value()) { + xfer += prot_->serializedFieldSize("common", apache::thrift::protocol::T_STRUCT, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::RequestCommon>::serializedSize(*prot_, this->common); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t AddVerticesRequest::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("AddVerticesRequest"); + xfer += prot_->writeFieldBegin("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::write(*prot_, this->space_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("parts", apache::thrift::protocol::T_MAP, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>>, std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::storage::cpp2::NewVertex>>>::write(*prot_, this->parts); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("prop_names", apache::thrift::protocol::T_MAP, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>>, std::unordered_map< ::nebula::cpp2::TagID, ::std::vector<::std::string>>>::write(*prot_, this->prop_names); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("if_not_exists", apache::thrift::protocol::T_BOOL, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::write(*prot_, this->if_not_exists); + xfer += prot_->writeFieldEnd(); + if (this->common_ref().has_value()) { + xfer += prot_->writeFieldBegin("common", apache::thrift::protocol::T_STRUCT, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::RequestCommon>::write(*prot_, this->common); + xfer += prot_->writeFieldEnd(); + } + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void AddVerticesRequest::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t AddVerticesRequest::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t AddVerticesRequest::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t AddVerticesRequest::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void AddVerticesRequest::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t AddVerticesRequest::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t AddVerticesRequest::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t AddVerticesRequest::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { + +template +void AddEdgesRequest::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_space_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::readWithContext(*iprot, this->space_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.space_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_MAP))) { + goto _loop; + } +_readField_parts: + { + _readState.beforeSubobject(iprot); + this->parts = std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::storage::cpp2::NewEdge>>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>>, std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::storage::cpp2::NewEdge>>>::readWithContext(*iprot, this->parts, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.parts = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_prop_names: + { + _readState.beforeSubobject(iprot); + this->prop_names = ::std::vector<::std::string>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>, ::std::vector<::std::string>>::readWithContext(*iprot, this->prop_names, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.prop_names = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 4, + apache::thrift::protocol::T_BOOL))) { + goto _loop; + } +_readField_if_not_exists: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::readWithContext(*iprot, this->if_not_exists, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.if_not_exists = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 4, + 5, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_common: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::RequestCommon>::readWithContext(*iprot, this->common, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.common = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 5, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_space_id; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_MAP))) { + goto _readField_parts; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_prop_names; + } else { + goto _skip; + } + } + case 4: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_BOOL))) { + goto _readField_if_not_exists; + } else { + goto _skip; + } + } + case 5: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_common; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t AddEdgesRequest::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("AddEdgesRequest"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("parts", apache::thrift::protocol::T_MAP, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>>, std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::storage::cpp2::NewEdge>>>::serializedSize(*prot_, this->parts); + xfer += prot_->serializedFieldSize("prop_names", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>, ::std::vector<::std::string>>::serializedSize(*prot_, this->prop_names); + xfer += prot_->serializedFieldSize("if_not_exists", apache::thrift::protocol::T_BOOL, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::serializedSize(*prot_, this->if_not_exists); + if (this->common_ref().has_value()) { + xfer += prot_->serializedFieldSize("common", apache::thrift::protocol::T_STRUCT, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::RequestCommon>::serializedSize(*prot_, this->common); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t AddEdgesRequest::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("AddEdgesRequest"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("parts", apache::thrift::protocol::T_MAP, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>>, std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::storage::cpp2::NewEdge>>>::serializedSize(*prot_, this->parts); + xfer += prot_->serializedFieldSize("prop_names", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>, ::std::vector<::std::string>>::serializedSize(*prot_, this->prop_names); + xfer += prot_->serializedFieldSize("if_not_exists", apache::thrift::protocol::T_BOOL, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::serializedSize(*prot_, this->if_not_exists); + if (this->common_ref().has_value()) { + xfer += prot_->serializedFieldSize("common", apache::thrift::protocol::T_STRUCT, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::RequestCommon>::serializedSize(*prot_, this->common); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t AddEdgesRequest::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("AddEdgesRequest"); + xfer += prot_->writeFieldBegin("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::write(*prot_, this->space_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("parts", apache::thrift::protocol::T_MAP, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>>, std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::storage::cpp2::NewEdge>>>::write(*prot_, this->parts); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("prop_names", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>, ::std::vector<::std::string>>::write(*prot_, this->prop_names); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("if_not_exists", apache::thrift::protocol::T_BOOL, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::write(*prot_, this->if_not_exists); + xfer += prot_->writeFieldEnd(); + if (this->common_ref().has_value()) { + xfer += prot_->writeFieldBegin("common", apache::thrift::protocol::T_STRUCT, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::RequestCommon>::write(*prot_, this->common); + xfer += prot_->writeFieldEnd(); + } + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void AddEdgesRequest::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t AddEdgesRequest::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t AddEdgesRequest::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t AddEdgesRequest::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void AddEdgesRequest::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t AddEdgesRequest::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t AddEdgesRequest::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t AddEdgesRequest::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { + +template +void DeleteVerticesRequest::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_space_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::readWithContext(*iprot, this->space_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.space_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_MAP))) { + goto _loop; + } +_readField_parts: + { + _readState.beforeSubobject(iprot); + this->parts = std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::variant>>, std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector>>::readWithContext(*iprot, this->parts, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.parts = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_common: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::RequestCommon>::readWithContext(*iprot, this->common, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.common = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_space_id; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_MAP))) { + goto _readField_parts; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_common; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t DeleteVerticesRequest::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("DeleteVerticesRequest"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("parts", apache::thrift::protocol::T_MAP, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::variant>>, std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector>>::serializedSize(*prot_, this->parts); + if (this->common_ref().has_value()) { + xfer += prot_->serializedFieldSize("common", apache::thrift::protocol::T_STRUCT, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::RequestCommon>::serializedSize(*prot_, this->common); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t DeleteVerticesRequest::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("DeleteVerticesRequest"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("parts", apache::thrift::protocol::T_MAP, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::variant>>, std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector>>::serializedSize(*prot_, this->parts); + if (this->common_ref().has_value()) { + xfer += prot_->serializedFieldSize("common", apache::thrift::protocol::T_STRUCT, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::RequestCommon>::serializedSize(*prot_, this->common); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t DeleteVerticesRequest::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("DeleteVerticesRequest"); + xfer += prot_->writeFieldBegin("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::write(*prot_, this->space_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("parts", apache::thrift::protocol::T_MAP, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::variant>>, std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector>>::write(*prot_, this->parts); + xfer += prot_->writeFieldEnd(); + if (this->common_ref().has_value()) { + xfer += prot_->writeFieldBegin("common", apache::thrift::protocol::T_STRUCT, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::RequestCommon>::write(*prot_, this->common); + xfer += prot_->writeFieldEnd(); + } + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void DeleteVerticesRequest::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t DeleteVerticesRequest::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t DeleteVerticesRequest::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t DeleteVerticesRequest::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void DeleteVerticesRequest::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t DeleteVerticesRequest::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t DeleteVerticesRequest::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t DeleteVerticesRequest::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { + +template +void DeleteEdgesRequest::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_space_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::readWithContext(*iprot, this->space_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.space_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_MAP))) { + goto _loop; + } +_readField_parts: + { + _readState.beforeSubobject(iprot); + this->parts = std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::storage::cpp2::EdgeKey>>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>>, std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::storage::cpp2::EdgeKey>>>::readWithContext(*iprot, this->parts, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.parts = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_common: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::RequestCommon>::readWithContext(*iprot, this->common, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.common = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_space_id; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_MAP))) { + goto _readField_parts; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_common; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t DeleteEdgesRequest::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("DeleteEdgesRequest"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("parts", apache::thrift::protocol::T_MAP, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>>, std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::storage::cpp2::EdgeKey>>>::serializedSize(*prot_, this->parts); + if (this->common_ref().has_value()) { + xfer += prot_->serializedFieldSize("common", apache::thrift::protocol::T_STRUCT, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::RequestCommon>::serializedSize(*prot_, this->common); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t DeleteEdgesRequest::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("DeleteEdgesRequest"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("parts", apache::thrift::protocol::T_MAP, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>>, std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::storage::cpp2::EdgeKey>>>::serializedSize(*prot_, this->parts); + if (this->common_ref().has_value()) { + xfer += prot_->serializedFieldSize("common", apache::thrift::protocol::T_STRUCT, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::RequestCommon>::serializedSize(*prot_, this->common); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t DeleteEdgesRequest::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("DeleteEdgesRequest"); + xfer += prot_->writeFieldBegin("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::write(*prot_, this->space_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("parts", apache::thrift::protocol::T_MAP, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>>, std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::storage::cpp2::EdgeKey>>>::write(*prot_, this->parts); + xfer += prot_->writeFieldEnd(); + if (this->common_ref().has_value()) { + xfer += prot_->writeFieldBegin("common", apache::thrift::protocol::T_STRUCT, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::RequestCommon>::write(*prot_, this->common); + xfer += prot_->writeFieldEnd(); + } + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void DeleteEdgesRequest::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t DeleteEdgesRequest::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t DeleteEdgesRequest::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t DeleteEdgesRequest::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void DeleteEdgesRequest::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t DeleteEdgesRequest::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t DeleteEdgesRequest::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t DeleteEdgesRequest::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { + +template +void DelTags::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_id: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::variant, nebula::Value>::readWithContext(*iprot, this->id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_tags: + { + _readState.beforeSubobject(iprot); + this->tags = ::std::vector< ::nebula::cpp2::TagID>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::integral>, ::std::vector< ::nebula::cpp2::TagID>>::readWithContext(*iprot, this->tags, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.tags = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_id; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_tags; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t DelTags::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("DelTags"); + xfer += prot_->serializedFieldSize("id", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::variant, nebula::Value>::serializedSize(*prot_, this->id); + xfer += prot_->serializedFieldSize("tags", apache::thrift::protocol::T_LIST, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::integral>, ::std::vector< ::nebula::cpp2::TagID>>::serializedSize(*prot_, this->tags); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t DelTags::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("DelTags"); + xfer += prot_->serializedFieldSize("id", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::variant, nebula::Value>::serializedSize(*prot_, this->id); + xfer += prot_->serializedFieldSize("tags", apache::thrift::protocol::T_LIST, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::integral>, ::std::vector< ::nebula::cpp2::TagID>>::serializedSize(*prot_, this->tags); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t DelTags::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("DelTags"); + xfer += prot_->writeFieldBegin("id", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::variant, nebula::Value>::write(*prot_, this->id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("tags", apache::thrift::protocol::T_LIST, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::integral>, ::std::vector< ::nebula::cpp2::TagID>>::write(*prot_, this->tags); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void DelTags::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t DelTags::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t DelTags::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t DelTags::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void DelTags::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t DelTags::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t DelTags::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t DelTags::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { + +template +void DeleteTagsRequest::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_space_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::readWithContext(*iprot, this->space_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.space_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_MAP))) { + goto _loop; + } +_readField_parts: + { + _readState.beforeSubobject(iprot); + this->parts = std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::storage::cpp2::DelTags>>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>>, std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::storage::cpp2::DelTags>>>::readWithContext(*iprot, this->parts, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.parts = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_common: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::RequestCommon>::readWithContext(*iprot, this->common, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.common = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_space_id; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_MAP))) { + goto _readField_parts; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_common; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t DeleteTagsRequest::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("DeleteTagsRequest"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("parts", apache::thrift::protocol::T_MAP, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>>, std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::storage::cpp2::DelTags>>>::serializedSize(*prot_, this->parts); + if (this->common_ref().has_value()) { + xfer += prot_->serializedFieldSize("common", apache::thrift::protocol::T_STRUCT, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::RequestCommon>::serializedSize(*prot_, this->common); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t DeleteTagsRequest::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("DeleteTagsRequest"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("parts", apache::thrift::protocol::T_MAP, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>>, std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::storage::cpp2::DelTags>>>::serializedSize(*prot_, this->parts); + if (this->common_ref().has_value()) { + xfer += prot_->serializedFieldSize("common", apache::thrift::protocol::T_STRUCT, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::RequestCommon>::serializedSize(*prot_, this->common); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t DeleteTagsRequest::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("DeleteTagsRequest"); + xfer += prot_->writeFieldBegin("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::write(*prot_, this->space_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("parts", apache::thrift::protocol::T_MAP, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>>, std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::storage::cpp2::DelTags>>>::write(*prot_, this->parts); + xfer += prot_->writeFieldEnd(); + if (this->common_ref().has_value()) { + xfer += prot_->writeFieldBegin("common", apache::thrift::protocol::T_STRUCT, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::RequestCommon>::write(*prot_, this->common); + xfer += prot_->writeFieldEnd(); + } + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void DeleteTagsRequest::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t DeleteTagsRequest::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t DeleteTagsRequest::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t DeleteTagsRequest::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void DeleteTagsRequest::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t DeleteTagsRequest::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t DeleteTagsRequest::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t DeleteTagsRequest::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { + +template +void UpdateResponse::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_result: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::ResponseCommon>::readWithContext(*iprot, this->result, _readState); + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_props: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::DataSet>::readWithContext(*iprot, this->props, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.props = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_result; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_props; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t UpdateResponse::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("UpdateResponse"); + xfer += prot_->serializedFieldSize("result", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::ResponseCommon>::serializedSize(*prot_, this->result); + if (this->props_ref().has_value()) { + xfer += prot_->serializedFieldSize("props", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::DataSet>::serializedSize(*prot_, this->props); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t UpdateResponse::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("UpdateResponse"); + xfer += prot_->serializedFieldSize("result", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::ResponseCommon>::serializedSize(*prot_, this->result); + if (this->props_ref().has_value()) { + xfer += prot_->serializedFieldSize("props", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::DataSet>::serializedSize(*prot_, this->props); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t UpdateResponse::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("UpdateResponse"); + xfer += prot_->writeFieldBegin("result", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::ResponseCommon>::write(*prot_, this->result); + xfer += prot_->writeFieldEnd(); + if (this->props_ref().has_value()) { + xfer += prot_->writeFieldBegin("props", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::DataSet>::write(*prot_, this->props); + xfer += prot_->writeFieldEnd(); + } + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void UpdateResponse::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t UpdateResponse::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t UpdateResponse::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t UpdateResponse::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void UpdateResponse::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t UpdateResponse::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t UpdateResponse::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t UpdateResponse::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { + +template +void UpdatedProp::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_name: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->name, _readState); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_value: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->value, _readState); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_name; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_value; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t UpdatedProp::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("UpdatedProp"); + xfer += prot_->serializedFieldSize("name", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->name); + xfer += prot_->serializedFieldSize("value", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->value); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t UpdatedProp::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("UpdatedProp"); + xfer += prot_->serializedFieldSize("name", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->name); + xfer += prot_->serializedFieldSize("value", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->value); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t UpdatedProp::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("UpdatedProp"); + xfer += prot_->writeFieldBegin("name", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->name); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("value", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->value); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void UpdatedProp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t UpdatedProp::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t UpdatedProp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t UpdatedProp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void UpdatedProp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t UpdatedProp::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t UpdatedProp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t UpdatedProp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { + +template +void UpdateVertexRequest::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_space_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::readWithContext(*iprot, this->space_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.space_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_part_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::PartitionID>::readWithContext(*iprot, this->part_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.part_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_vertex_id: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::variant, nebula::Value>::readWithContext(*iprot, this->vertex_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.vertex_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 4, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_tag_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::TagID>::readWithContext(*iprot, this->tag_id, _readState); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 4, + 5, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_updated_props: + { + _readState.beforeSubobject(iprot); + this->updated_props = ::std::vector< ::nebula::storage::cpp2::UpdatedProp>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::storage::cpp2::UpdatedProp>>::readWithContext(*iprot, this->updated_props, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.updated_props = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 5, + 6, + apache::thrift::protocol::T_BOOL))) { + goto _loop; + } +_readField_insertable: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::readWithContext(*iprot, this->insertable, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.insertable = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 6, + 7, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_return_props: + { + _readState.beforeSubobject(iprot); + this->return_props = ::std::vector<::std::string>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>, ::std::vector<::std::string>>::readWithContext(*iprot, this->return_props, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.return_props = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 7, + 8, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_condition: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->condition, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.condition = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 8, + 9, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_common: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::RequestCommon>::readWithContext(*iprot, this->common, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.common = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 9, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_space_id; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_part_id; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_vertex_id; + } else { + goto _skip; + } + } + case 4: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_tag_id; + } else { + goto _skip; + } + } + case 5: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_updated_props; + } else { + goto _skip; + } + } + case 6: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_BOOL))) { + goto _readField_insertable; + } else { + goto _skip; + } + } + case 7: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_return_props; + } else { + goto _skip; + } + } + case 8: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_condition; + } else { + goto _skip; + } + } + case 9: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_common; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t UpdateVertexRequest::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("UpdateVertexRequest"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("part_id", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::PartitionID>::serializedSize(*prot_, this->part_id); + xfer += prot_->serializedFieldSize("vertex_id", apache::thrift::protocol::T_STRUCT, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::variant, nebula::Value>::serializedSize(*prot_, this->vertex_id); + xfer += prot_->serializedFieldSize("tag_id", apache::thrift::protocol::T_I32, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::TagID>::serializedSize(*prot_, this->tag_id); + xfer += prot_->serializedFieldSize("updated_props", apache::thrift::protocol::T_LIST, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::storage::cpp2::UpdatedProp>>::serializedSize(*prot_, this->updated_props); + if (this->insertable_ref().has_value()) { + xfer += prot_->serializedFieldSize("insertable", apache::thrift::protocol::T_BOOL, 6); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::serializedSize(*prot_, this->insertable); + } + if (this->return_props_ref().has_value()) { + xfer += prot_->serializedFieldSize("return_props", apache::thrift::protocol::T_LIST, 7); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>, ::std::vector<::std::string>>::serializedSize(*prot_, this->return_props); + } + if (this->condition_ref().has_value()) { + xfer += prot_->serializedFieldSize("condition", apache::thrift::protocol::T_STRING, 8); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->condition); + } + if (this->common_ref().has_value()) { + xfer += prot_->serializedFieldSize("common", apache::thrift::protocol::T_STRUCT, 9); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::RequestCommon>::serializedSize(*prot_, this->common); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t UpdateVertexRequest::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("UpdateVertexRequest"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("part_id", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::PartitionID>::serializedSize(*prot_, this->part_id); + xfer += prot_->serializedFieldSize("vertex_id", apache::thrift::protocol::T_STRUCT, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::variant, nebula::Value>::serializedSize(*prot_, this->vertex_id); + xfer += prot_->serializedFieldSize("tag_id", apache::thrift::protocol::T_I32, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::TagID>::serializedSize(*prot_, this->tag_id); + xfer += prot_->serializedFieldSize("updated_props", apache::thrift::protocol::T_LIST, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::storage::cpp2::UpdatedProp>>::serializedSize(*prot_, this->updated_props); + if (this->insertable_ref().has_value()) { + xfer += prot_->serializedFieldSize("insertable", apache::thrift::protocol::T_BOOL, 6); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::serializedSize(*prot_, this->insertable); + } + if (this->return_props_ref().has_value()) { + xfer += prot_->serializedFieldSize("return_props", apache::thrift::protocol::T_LIST, 7); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>, ::std::vector<::std::string>>::serializedSize(*prot_, this->return_props); + } + if (this->condition_ref().has_value()) { + xfer += prot_->serializedFieldSize("condition", apache::thrift::protocol::T_STRING, 8); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->condition); + } + if (this->common_ref().has_value()) { + xfer += prot_->serializedFieldSize("common", apache::thrift::protocol::T_STRUCT, 9); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::RequestCommon>::serializedSize(*prot_, this->common); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t UpdateVertexRequest::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("UpdateVertexRequest"); + xfer += prot_->writeFieldBegin("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::write(*prot_, this->space_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("part_id", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::PartitionID>::write(*prot_, this->part_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("vertex_id", apache::thrift::protocol::T_STRUCT, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::variant, nebula::Value>::write(*prot_, this->vertex_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("tag_id", apache::thrift::protocol::T_I32, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::TagID>::write(*prot_, this->tag_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("updated_props", apache::thrift::protocol::T_LIST, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::storage::cpp2::UpdatedProp>>::write(*prot_, this->updated_props); + xfer += prot_->writeFieldEnd(); + if (this->insertable_ref().has_value()) { + xfer += prot_->writeFieldBegin("insertable", apache::thrift::protocol::T_BOOL, 6); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::write(*prot_, this->insertable); + xfer += prot_->writeFieldEnd(); + } + if (this->return_props_ref().has_value()) { + xfer += prot_->writeFieldBegin("return_props", apache::thrift::protocol::T_LIST, 7); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>, ::std::vector<::std::string>>::write(*prot_, this->return_props); + xfer += prot_->writeFieldEnd(); + } + if (this->condition_ref().has_value()) { + xfer += prot_->writeFieldBegin("condition", apache::thrift::protocol::T_STRING, 8); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->condition); + xfer += prot_->writeFieldEnd(); + } + if (this->common_ref().has_value()) { + xfer += prot_->writeFieldBegin("common", apache::thrift::protocol::T_STRUCT, 9); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::RequestCommon>::write(*prot_, this->common); + xfer += prot_->writeFieldEnd(); + } + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void UpdateVertexRequest::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t UpdateVertexRequest::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t UpdateVertexRequest::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t UpdateVertexRequest::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void UpdateVertexRequest::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t UpdateVertexRequest::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t UpdateVertexRequest::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t UpdateVertexRequest::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { + +template +void UpdateEdgeRequest::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_space_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::readWithContext(*iprot, this->space_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.space_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_part_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::PartitionID>::readWithContext(*iprot, this->part_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.part_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_edge_key: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::EdgeKey>::readWithContext(*iprot, this->edge_key, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.edge_key = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 4, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_updated_props: + { + _readState.beforeSubobject(iprot); + this->updated_props = ::std::vector< ::nebula::storage::cpp2::UpdatedProp>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::storage::cpp2::UpdatedProp>>::readWithContext(*iprot, this->updated_props, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.updated_props = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 4, + 5, + apache::thrift::protocol::T_BOOL))) { + goto _loop; + } +_readField_insertable: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::readWithContext(*iprot, this->insertable, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.insertable = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 5, + 6, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_return_props: + { + _readState.beforeSubobject(iprot); + this->return_props = ::std::vector<::std::string>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>, ::std::vector<::std::string>>::readWithContext(*iprot, this->return_props, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.return_props = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 6, + 7, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_condition: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->condition, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.condition = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 7, + 8, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_common: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::RequestCommon>::readWithContext(*iprot, this->common, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.common = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 8, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_space_id; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_part_id; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_edge_key; + } else { + goto _skip; + } + } + case 4: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_updated_props; + } else { + goto _skip; + } + } + case 5: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_BOOL))) { + goto _readField_insertable; + } else { + goto _skip; + } + } + case 6: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_return_props; + } else { + goto _skip; + } + } + case 7: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_condition; + } else { + goto _skip; + } + } + case 8: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_common; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t UpdateEdgeRequest::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("UpdateEdgeRequest"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("part_id", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::PartitionID>::serializedSize(*prot_, this->part_id); + xfer += prot_->serializedFieldSize("edge_key", apache::thrift::protocol::T_STRUCT, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::EdgeKey>::serializedSize(*prot_, this->edge_key); + xfer += prot_->serializedFieldSize("updated_props", apache::thrift::protocol::T_LIST, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::storage::cpp2::UpdatedProp>>::serializedSize(*prot_, this->updated_props); + if (this->insertable_ref().has_value()) { + xfer += prot_->serializedFieldSize("insertable", apache::thrift::protocol::T_BOOL, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::serializedSize(*prot_, this->insertable); + } + if (this->return_props_ref().has_value()) { + xfer += prot_->serializedFieldSize("return_props", apache::thrift::protocol::T_LIST, 6); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>, ::std::vector<::std::string>>::serializedSize(*prot_, this->return_props); + } + if (this->condition_ref().has_value()) { + xfer += prot_->serializedFieldSize("condition", apache::thrift::protocol::T_STRING, 7); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->condition); + } + if (this->common_ref().has_value()) { + xfer += prot_->serializedFieldSize("common", apache::thrift::protocol::T_STRUCT, 8); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::RequestCommon>::serializedSize(*prot_, this->common); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t UpdateEdgeRequest::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("UpdateEdgeRequest"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("part_id", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::PartitionID>::serializedSize(*prot_, this->part_id); + xfer += prot_->serializedFieldSize("edge_key", apache::thrift::protocol::T_STRUCT, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::EdgeKey>::serializedSize(*prot_, this->edge_key); + xfer += prot_->serializedFieldSize("updated_props", apache::thrift::protocol::T_LIST, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::storage::cpp2::UpdatedProp>>::serializedSize(*prot_, this->updated_props); + if (this->insertable_ref().has_value()) { + xfer += prot_->serializedFieldSize("insertable", apache::thrift::protocol::T_BOOL, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::serializedSize(*prot_, this->insertable); + } + if (this->return_props_ref().has_value()) { + xfer += prot_->serializedFieldSize("return_props", apache::thrift::protocol::T_LIST, 6); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>, ::std::vector<::std::string>>::serializedSize(*prot_, this->return_props); + } + if (this->condition_ref().has_value()) { + xfer += prot_->serializedFieldSize("condition", apache::thrift::protocol::T_STRING, 7); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->condition); + } + if (this->common_ref().has_value()) { + xfer += prot_->serializedFieldSize("common", apache::thrift::protocol::T_STRUCT, 8); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::RequestCommon>::serializedSize(*prot_, this->common); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t UpdateEdgeRequest::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("UpdateEdgeRequest"); + xfer += prot_->writeFieldBegin("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::write(*prot_, this->space_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("part_id", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::PartitionID>::write(*prot_, this->part_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("edge_key", apache::thrift::protocol::T_STRUCT, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::EdgeKey>::write(*prot_, this->edge_key); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("updated_props", apache::thrift::protocol::T_LIST, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::storage::cpp2::UpdatedProp>>::write(*prot_, this->updated_props); + xfer += prot_->writeFieldEnd(); + if (this->insertable_ref().has_value()) { + xfer += prot_->writeFieldBegin("insertable", apache::thrift::protocol::T_BOOL, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::write(*prot_, this->insertable); + xfer += prot_->writeFieldEnd(); + } + if (this->return_props_ref().has_value()) { + xfer += prot_->writeFieldBegin("return_props", apache::thrift::protocol::T_LIST, 6); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>, ::std::vector<::std::string>>::write(*prot_, this->return_props); + xfer += prot_->writeFieldEnd(); + } + if (this->condition_ref().has_value()) { + xfer += prot_->writeFieldBegin("condition", apache::thrift::protocol::T_STRING, 7); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->condition); + xfer += prot_->writeFieldEnd(); + } + if (this->common_ref().has_value()) { + xfer += prot_->writeFieldBegin("common", apache::thrift::protocol::T_STRUCT, 8); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::RequestCommon>::write(*prot_, this->common); + xfer += prot_->writeFieldEnd(); + } + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void UpdateEdgeRequest::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t UpdateEdgeRequest::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t UpdateEdgeRequest::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t UpdateEdgeRequest::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void UpdateEdgeRequest::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t UpdateEdgeRequest::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t UpdateEdgeRequest::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t UpdateEdgeRequest::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { + +template +void GetUUIDReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_space_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::readWithContext(*iprot, this->space_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.space_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_part_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::PartitionID>::readWithContext(*iprot, this->part_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.part_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_name: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->name, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.name = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 4, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_common: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::RequestCommon>::readWithContext(*iprot, this->common, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.common = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 4, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_space_id; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_part_id; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_name; + } else { + goto _skip; + } + } + case 4: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_common; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t GetUUIDReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("GetUUIDReq"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("part_id", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::PartitionID>::serializedSize(*prot_, this->part_id); + xfer += prot_->serializedFieldSize("name", apache::thrift::protocol::T_STRING, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->name); + if (this->common_ref().has_value()) { + xfer += prot_->serializedFieldSize("common", apache::thrift::protocol::T_STRUCT, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::RequestCommon>::serializedSize(*prot_, this->common); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t GetUUIDReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("GetUUIDReq"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("part_id", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::PartitionID>::serializedSize(*prot_, this->part_id); + xfer += prot_->serializedFieldSize("name", apache::thrift::protocol::T_STRING, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->name); + if (this->common_ref().has_value()) { + xfer += prot_->serializedFieldSize("common", apache::thrift::protocol::T_STRUCT, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::RequestCommon>::serializedSize(*prot_, this->common); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t GetUUIDReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("GetUUIDReq"); + xfer += prot_->writeFieldBegin("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::write(*prot_, this->space_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("part_id", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::PartitionID>::write(*prot_, this->part_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("name", apache::thrift::protocol::T_STRING, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->name); + xfer += prot_->writeFieldEnd(); + if (this->common_ref().has_value()) { + xfer += prot_->writeFieldBegin("common", apache::thrift::protocol::T_STRUCT, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::RequestCommon>::write(*prot_, this->common); + xfer += prot_->writeFieldEnd(); + } + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void GetUUIDReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t GetUUIDReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t GetUUIDReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t GetUUIDReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void GetUUIDReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t GetUUIDReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t GetUUIDReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t GetUUIDReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { + +template +void GetUUIDResp::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_result: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::ResponseCommon>::readWithContext(*iprot, this->result, _readState); + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_id: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::variant, nebula::Value>::readWithContext(*iprot, this->id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_result; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_id; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t GetUUIDResp::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("GetUUIDResp"); + xfer += prot_->serializedFieldSize("result", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::ResponseCommon>::serializedSize(*prot_, this->result); + xfer += prot_->serializedFieldSize("id", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::variant, nebula::Value>::serializedSize(*prot_, this->id); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t GetUUIDResp::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("GetUUIDResp"); + xfer += prot_->serializedFieldSize("result", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::ResponseCommon>::serializedSize(*prot_, this->result); + xfer += prot_->serializedFieldSize("id", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::variant, nebula::Value>::serializedSize(*prot_, this->id); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t GetUUIDResp::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("GetUUIDResp"); + xfer += prot_->writeFieldBegin("result", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::ResponseCommon>::write(*prot_, this->result); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("id", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::variant, nebula::Value>::write(*prot_, this->id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void GetUUIDResp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t GetUUIDResp::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t GetUUIDResp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t GetUUIDResp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void GetUUIDResp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t GetUUIDResp::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t GetUUIDResp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t GetUUIDResp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { + +template +void LookupIndexResp::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_result: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::ResponseCommon>::readWithContext(*iprot, this->result, _readState); + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_data: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::DataSet>::readWithContext(*iprot, this->data, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.data = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_result; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_data; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t LookupIndexResp::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("LookupIndexResp"); + xfer += prot_->serializedFieldSize("result", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::ResponseCommon>::serializedSize(*prot_, this->result); + if (this->data_ref().has_value()) { + xfer += prot_->serializedFieldSize("data", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::DataSet>::serializedSize(*prot_, this->data); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t LookupIndexResp::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("LookupIndexResp"); + xfer += prot_->serializedFieldSize("result", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::ResponseCommon>::serializedSize(*prot_, this->result); + if (this->data_ref().has_value()) { + xfer += prot_->serializedFieldSize("data", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::DataSet>::serializedSize(*prot_, this->data); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t LookupIndexResp::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("LookupIndexResp"); + xfer += prot_->writeFieldBegin("result", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::ResponseCommon>::write(*prot_, this->result); + xfer += prot_->writeFieldEnd(); + if (this->data_ref().has_value()) { + xfer += prot_->writeFieldBegin("data", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::DataSet>::write(*prot_, this->data); + xfer += prot_->writeFieldEnd(); + } + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void LookupIndexResp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t LookupIndexResp::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t LookupIndexResp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t LookupIndexResp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void LookupIndexResp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t LookupIndexResp::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t LookupIndexResp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t LookupIndexResp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { + +template +void IndexColumnHint::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_column_name: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->column_name, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.column_name = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_scan_type: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::storage::cpp2::ScanType>::readWithContext(*iprot, this->scan_type, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.scan_type = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_begin_value: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::variant, nebula::Value>::readWithContext(*iprot, this->begin_value, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.begin_value = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 4, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_end_value: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::variant, nebula::Value>::readWithContext(*iprot, this->end_value, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.end_value = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 4, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_column_name; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_scan_type; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_begin_value; + } else { + goto _skip; + } + } + case 4: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_end_value; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t IndexColumnHint::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("IndexColumnHint"); + xfer += prot_->serializedFieldSize("column_name", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->column_name); + xfer += prot_->serializedFieldSize("scan_type", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::storage::cpp2::ScanType>::serializedSize(*prot_, this->scan_type); + xfer += prot_->serializedFieldSize("begin_value", apache::thrift::protocol::T_STRUCT, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::variant, nebula::Value>::serializedSize(*prot_, this->begin_value); + xfer += prot_->serializedFieldSize("end_value", apache::thrift::protocol::T_STRUCT, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::variant, nebula::Value>::serializedSize(*prot_, this->end_value); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t IndexColumnHint::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("IndexColumnHint"); + xfer += prot_->serializedFieldSize("column_name", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->column_name); + xfer += prot_->serializedFieldSize("scan_type", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::storage::cpp2::ScanType>::serializedSize(*prot_, this->scan_type); + xfer += prot_->serializedFieldSize("begin_value", apache::thrift::protocol::T_STRUCT, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::variant, nebula::Value>::serializedSize(*prot_, this->begin_value); + xfer += prot_->serializedFieldSize("end_value", apache::thrift::protocol::T_STRUCT, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::variant, nebula::Value>::serializedSize(*prot_, this->end_value); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t IndexColumnHint::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("IndexColumnHint"); + xfer += prot_->writeFieldBegin("column_name", apache::thrift::protocol::T_STRING, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->column_name); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("scan_type", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::storage::cpp2::ScanType>::write(*prot_, this->scan_type); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("begin_value", apache::thrift::protocol::T_STRUCT, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::variant, nebula::Value>::write(*prot_, this->begin_value); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("end_value", apache::thrift::protocol::T_STRUCT, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::variant, nebula::Value>::write(*prot_, this->end_value); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void IndexColumnHint::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t IndexColumnHint::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t IndexColumnHint::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t IndexColumnHint::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void IndexColumnHint::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t IndexColumnHint::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t IndexColumnHint::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t IndexColumnHint::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { + +template +void IndexQueryContext::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_index_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::IndexID>::readWithContext(*iprot, this->index_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.index_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_filter: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->filter, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.filter = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_column_hints: + { + _readState.beforeSubobject(iprot); + this->column_hints = ::std::vector< ::nebula::storage::cpp2::IndexColumnHint>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::storage::cpp2::IndexColumnHint>>::readWithContext(*iprot, this->column_hints, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.column_hints = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_index_id; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_filter; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_column_hints; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t IndexQueryContext::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("IndexQueryContext"); + xfer += prot_->serializedFieldSize("index_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::IndexID>::serializedSize(*prot_, this->index_id); + xfer += prot_->serializedFieldSize("filter", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->filter); + xfer += prot_->serializedFieldSize("column_hints", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::storage::cpp2::IndexColumnHint>>::serializedSize(*prot_, this->column_hints); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t IndexQueryContext::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("IndexQueryContext"); + xfer += prot_->serializedFieldSize("index_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::IndexID>::serializedSize(*prot_, this->index_id); + xfer += prot_->serializedFieldSize("filter", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->filter); + xfer += prot_->serializedFieldSize("column_hints", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::storage::cpp2::IndexColumnHint>>::serializedSize(*prot_, this->column_hints); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t IndexQueryContext::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("IndexQueryContext"); + xfer += prot_->writeFieldBegin("index_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::IndexID>::write(*prot_, this->index_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("filter", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->filter); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("column_hints", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::storage::cpp2::IndexColumnHint>>::write(*prot_, this->column_hints); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void IndexQueryContext::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t IndexQueryContext::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t IndexQueryContext::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t IndexQueryContext::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void IndexQueryContext::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t IndexQueryContext::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t IndexQueryContext::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t IndexQueryContext::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { + +template +void IndexSpec::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_contexts: + { + _readState.beforeSubobject(iprot); + this->contexts = ::std::vector< ::nebula::storage::cpp2::IndexQueryContext>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::storage::cpp2::IndexQueryContext>>::readWithContext(*iprot, this->contexts, _readState); + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_schema_id: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::variant, ::nebula::cpp2::SchemaID>::readWithContext(*iprot, this->schema_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.schema_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_contexts; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_schema_id; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t IndexSpec::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("IndexSpec"); + xfer += prot_->serializedFieldSize("contexts", apache::thrift::protocol::T_LIST, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::storage::cpp2::IndexQueryContext>>::serializedSize(*prot_, this->contexts); + xfer += prot_->serializedFieldSize("schema_id", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::variant, ::nebula::cpp2::SchemaID>::serializedSize(*prot_, this->schema_id); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t IndexSpec::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("IndexSpec"); + xfer += prot_->serializedFieldSize("contexts", apache::thrift::protocol::T_LIST, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::storage::cpp2::IndexQueryContext>>::serializedSize(*prot_, this->contexts); + xfer += prot_->serializedFieldSize("schema_id", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::variant, ::nebula::cpp2::SchemaID>::serializedSize(*prot_, this->schema_id); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t IndexSpec::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("IndexSpec"); + xfer += prot_->writeFieldBegin("contexts", apache::thrift::protocol::T_LIST, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::storage::cpp2::IndexQueryContext>>::write(*prot_, this->contexts); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("schema_id", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::variant, ::nebula::cpp2::SchemaID>::write(*prot_, this->schema_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void IndexSpec::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t IndexSpec::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t IndexSpec::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t IndexSpec::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void IndexSpec::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t IndexSpec::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t IndexSpec::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t IndexSpec::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { + +template +void LookupIndexRequest::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_space_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::readWithContext(*iprot, this->space_id, _readState); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_parts: + { + _readState.beforeSubobject(iprot); + this->parts = ::std::vector< ::nebula::cpp2::PartitionID>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::integral>, ::std::vector< ::nebula::cpp2::PartitionID>>::readWithContext(*iprot, this->parts, _readState); + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_indices: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::IndexSpec>::readWithContext(*iprot, this->indices, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.indices = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 4, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_return_columns: + { + _readState.beforeSubobject(iprot); + this->return_columns = ::std::vector<::std::string>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>, ::std::vector<::std::string>>::readWithContext(*iprot, this->return_columns, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.return_columns = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 4, + 5, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_common: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::RequestCommon>::readWithContext(*iprot, this->common, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.common = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 5, + 6, + apache::thrift::protocol::T_I64))) { + goto _loop; + } +_readField_limit: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::readWithContext(*iprot, this->limit, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.limit = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 6, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_space_id; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_parts; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_indices; + } else { + goto _skip; + } + } + case 4: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_return_columns; + } else { + goto _skip; + } + } + case 5: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_common; + } else { + goto _skip; + } + } + case 6: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I64))) { + goto _readField_limit; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t LookupIndexRequest::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("LookupIndexRequest"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("parts", apache::thrift::protocol::T_LIST, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::integral>, ::std::vector< ::nebula::cpp2::PartitionID>>::serializedSize(*prot_, this->parts); + xfer += prot_->serializedFieldSize("indices", apache::thrift::protocol::T_STRUCT, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::IndexSpec>::serializedSize(*prot_, this->indices); + if (this->return_columns_ref().has_value()) { + xfer += prot_->serializedFieldSize("return_columns", apache::thrift::protocol::T_LIST, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>, ::std::vector<::std::string>>::serializedSize(*prot_, this->return_columns); + } + if (this->common_ref().has_value()) { + xfer += prot_->serializedFieldSize("common", apache::thrift::protocol::T_STRUCT, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::RequestCommon>::serializedSize(*prot_, this->common); + } + if (this->limit_ref().has_value()) { + xfer += prot_->serializedFieldSize("limit", apache::thrift::protocol::T_I64, 6); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::serializedSize(*prot_, this->limit); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t LookupIndexRequest::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("LookupIndexRequest"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("parts", apache::thrift::protocol::T_LIST, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::integral>, ::std::vector< ::nebula::cpp2::PartitionID>>::serializedSize(*prot_, this->parts); + xfer += prot_->serializedFieldSize("indices", apache::thrift::protocol::T_STRUCT, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::IndexSpec>::serializedSize(*prot_, this->indices); + if (this->return_columns_ref().has_value()) { + xfer += prot_->serializedFieldSize("return_columns", apache::thrift::protocol::T_LIST, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>, ::std::vector<::std::string>>::serializedSize(*prot_, this->return_columns); + } + if (this->common_ref().has_value()) { + xfer += prot_->serializedFieldSize("common", apache::thrift::protocol::T_STRUCT, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::RequestCommon>::serializedSize(*prot_, this->common); + } + if (this->limit_ref().has_value()) { + xfer += prot_->serializedFieldSize("limit", apache::thrift::protocol::T_I64, 6); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::serializedSize(*prot_, this->limit); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t LookupIndexRequest::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("LookupIndexRequest"); + xfer += prot_->writeFieldBegin("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::write(*prot_, this->space_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("parts", apache::thrift::protocol::T_LIST, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::integral>, ::std::vector< ::nebula::cpp2::PartitionID>>::write(*prot_, this->parts); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("indices", apache::thrift::protocol::T_STRUCT, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::IndexSpec>::write(*prot_, this->indices); + xfer += prot_->writeFieldEnd(); + if (this->return_columns_ref().has_value()) { + xfer += prot_->writeFieldBegin("return_columns", apache::thrift::protocol::T_LIST, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>, ::std::vector<::std::string>>::write(*prot_, this->return_columns); + xfer += prot_->writeFieldEnd(); + } + if (this->common_ref().has_value()) { + xfer += prot_->writeFieldBegin("common", apache::thrift::protocol::T_STRUCT, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::RequestCommon>::write(*prot_, this->common); + xfer += prot_->writeFieldEnd(); + } + if (this->limit_ref().has_value()) { + xfer += prot_->writeFieldBegin("limit", apache::thrift::protocol::T_I64, 6); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::write(*prot_, this->limit); + xfer += prot_->writeFieldEnd(); + } + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void LookupIndexRequest::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t LookupIndexRequest::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t LookupIndexRequest::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t LookupIndexRequest::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void LookupIndexRequest::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t LookupIndexRequest::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t LookupIndexRequest::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t LookupIndexRequest::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { + +template +void LookupAndTraverseRequest::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_space_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::readWithContext(*iprot, this->space_id, _readState); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_parts: + { + _readState.beforeSubobject(iprot); + this->parts = ::std::vector< ::nebula::cpp2::PartitionID>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::integral>, ::std::vector< ::nebula::cpp2::PartitionID>>::readWithContext(*iprot, this->parts, _readState); + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_indices: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::IndexSpec>::readWithContext(*iprot, this->indices, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.indices = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 4, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_traverse_spec: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::TraverseSpec>::readWithContext(*iprot, this->traverse_spec, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.traverse_spec = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 4, + 5, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_common: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::RequestCommon>::readWithContext(*iprot, this->common, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.common = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 5, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_space_id; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_parts; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_indices; + } else { + goto _skip; + } + } + case 4: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_traverse_spec; + } else { + goto _skip; + } + } + case 5: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_common; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t LookupAndTraverseRequest::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("LookupAndTraverseRequest"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("parts", apache::thrift::protocol::T_LIST, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::integral>, ::std::vector< ::nebula::cpp2::PartitionID>>::serializedSize(*prot_, this->parts); + xfer += prot_->serializedFieldSize("indices", apache::thrift::protocol::T_STRUCT, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::IndexSpec>::serializedSize(*prot_, this->indices); + xfer += prot_->serializedFieldSize("traverse_spec", apache::thrift::protocol::T_STRUCT, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::TraverseSpec>::serializedSize(*prot_, this->traverse_spec); + if (this->common_ref().has_value()) { + xfer += prot_->serializedFieldSize("common", apache::thrift::protocol::T_STRUCT, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::RequestCommon>::serializedSize(*prot_, this->common); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t LookupAndTraverseRequest::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("LookupAndTraverseRequest"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("parts", apache::thrift::protocol::T_LIST, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::integral>, ::std::vector< ::nebula::cpp2::PartitionID>>::serializedSize(*prot_, this->parts); + xfer += prot_->serializedFieldSize("indices", apache::thrift::protocol::T_STRUCT, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::IndexSpec>::serializedSize(*prot_, this->indices); + xfer += prot_->serializedFieldSize("traverse_spec", apache::thrift::protocol::T_STRUCT, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::TraverseSpec>::serializedSize(*prot_, this->traverse_spec); + if (this->common_ref().has_value()) { + xfer += prot_->serializedFieldSize("common", apache::thrift::protocol::T_STRUCT, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::RequestCommon>::serializedSize(*prot_, this->common); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t LookupAndTraverseRequest::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("LookupAndTraverseRequest"); + xfer += prot_->writeFieldBegin("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::write(*prot_, this->space_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("parts", apache::thrift::protocol::T_LIST, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::integral>, ::std::vector< ::nebula::cpp2::PartitionID>>::write(*prot_, this->parts); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("indices", apache::thrift::protocol::T_STRUCT, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::IndexSpec>::write(*prot_, this->indices); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("traverse_spec", apache::thrift::protocol::T_STRUCT, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::TraverseSpec>::write(*prot_, this->traverse_spec); + xfer += prot_->writeFieldEnd(); + if (this->common_ref().has_value()) { + xfer += prot_->writeFieldBegin("common", apache::thrift::protocol::T_STRUCT, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::RequestCommon>::write(*prot_, this->common); + xfer += prot_->writeFieldEnd(); + } + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void LookupAndTraverseRequest::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t LookupAndTraverseRequest::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t LookupAndTraverseRequest::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t LookupAndTraverseRequest::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void LookupAndTraverseRequest::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t LookupAndTraverseRequest::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t LookupAndTraverseRequest::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t LookupAndTraverseRequest::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { + +template +void ScanVertexRequest::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_space_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::readWithContext(*iprot, this->space_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.space_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_part_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::PartitionID>::readWithContext(*iprot, this->part_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.part_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_cursor: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->cursor, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.cursor = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 4, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_return_columns: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::VertexProp>::readWithContext(*iprot, this->return_columns, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.return_columns = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 4, + 5, + apache::thrift::protocol::T_I64))) { + goto _loop; + } +_readField_limit: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::readWithContext(*iprot, this->limit, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.limit = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 5, + 6, + apache::thrift::protocol::T_I64))) { + goto _loop; + } +_readField_start_time: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::readWithContext(*iprot, this->start_time, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.start_time = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 6, + 7, + apache::thrift::protocol::T_I64))) { + goto _loop; + } +_readField_end_time: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::readWithContext(*iprot, this->end_time, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.end_time = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 7, + 8, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_filter: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->filter, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.filter = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 8, + 9, + apache::thrift::protocol::T_BOOL))) { + goto _loop; + } +_readField_only_latest_version: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::readWithContext(*iprot, this->only_latest_version, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.only_latest_version = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 9, + 10, + apache::thrift::protocol::T_BOOL))) { + goto _loop; + } +_readField_enable_read_from_follower: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::readWithContext(*iprot, this->enable_read_from_follower, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.enable_read_from_follower = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 10, + 11, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_common: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::RequestCommon>::readWithContext(*iprot, this->common, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.common = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 11, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_space_id; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_part_id; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_cursor; + } else { + goto _skip; + } + } + case 4: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_return_columns; + } else { + goto _skip; + } + } + case 5: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I64))) { + goto _readField_limit; + } else { + goto _skip; + } + } + case 6: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I64))) { + goto _readField_start_time; + } else { + goto _skip; + } + } + case 7: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I64))) { + goto _readField_end_time; + } else { + goto _skip; + } + } + case 8: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_filter; + } else { + goto _skip; + } + } + case 9: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_BOOL))) { + goto _readField_only_latest_version; + } else { + goto _skip; + } + } + case 10: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_BOOL))) { + goto _readField_enable_read_from_follower; + } else { + goto _skip; + } + } + case 11: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_common; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t ScanVertexRequest::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ScanVertexRequest"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("part_id", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::PartitionID>::serializedSize(*prot_, this->part_id); + if (this->cursor_ref().has_value()) { + xfer += prot_->serializedFieldSize("cursor", apache::thrift::protocol::T_STRING, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->cursor); + } + xfer += prot_->serializedFieldSize("return_columns", apache::thrift::protocol::T_STRUCT, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::VertexProp>::serializedSize(*prot_, this->return_columns); + xfer += prot_->serializedFieldSize("limit", apache::thrift::protocol::T_I64, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::serializedSize(*prot_, this->limit); + if (this->start_time_ref().has_value()) { + xfer += prot_->serializedFieldSize("start_time", apache::thrift::protocol::T_I64, 6); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::serializedSize(*prot_, this->start_time); + } + if (this->end_time_ref().has_value()) { + xfer += prot_->serializedFieldSize("end_time", apache::thrift::protocol::T_I64, 7); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::serializedSize(*prot_, this->end_time); + } + if (this->filter_ref().has_value()) { + xfer += prot_->serializedFieldSize("filter", apache::thrift::protocol::T_STRING, 8); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->filter); + } + xfer += prot_->serializedFieldSize("only_latest_version", apache::thrift::protocol::T_BOOL, 9); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::serializedSize(*prot_, this->only_latest_version); + xfer += prot_->serializedFieldSize("enable_read_from_follower", apache::thrift::protocol::T_BOOL, 10); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::serializedSize(*prot_, this->enable_read_from_follower); + if (this->common_ref().has_value()) { + xfer += prot_->serializedFieldSize("common", apache::thrift::protocol::T_STRUCT, 11); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::RequestCommon>::serializedSize(*prot_, this->common); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ScanVertexRequest::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ScanVertexRequest"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("part_id", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::PartitionID>::serializedSize(*prot_, this->part_id); + if (this->cursor_ref().has_value()) { + xfer += prot_->serializedFieldSize("cursor", apache::thrift::protocol::T_STRING, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->cursor); + } + xfer += prot_->serializedFieldSize("return_columns", apache::thrift::protocol::T_STRUCT, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::VertexProp>::serializedSize(*prot_, this->return_columns); + xfer += prot_->serializedFieldSize("limit", apache::thrift::protocol::T_I64, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::serializedSize(*prot_, this->limit); + if (this->start_time_ref().has_value()) { + xfer += prot_->serializedFieldSize("start_time", apache::thrift::protocol::T_I64, 6); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::serializedSize(*prot_, this->start_time); + } + if (this->end_time_ref().has_value()) { + xfer += prot_->serializedFieldSize("end_time", apache::thrift::protocol::T_I64, 7); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::serializedSize(*prot_, this->end_time); + } + if (this->filter_ref().has_value()) { + xfer += prot_->serializedFieldSize("filter", apache::thrift::protocol::T_STRING, 8); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->filter); + } + xfer += prot_->serializedFieldSize("only_latest_version", apache::thrift::protocol::T_BOOL, 9); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::serializedSize(*prot_, this->only_latest_version); + xfer += prot_->serializedFieldSize("enable_read_from_follower", apache::thrift::protocol::T_BOOL, 10); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::serializedSize(*prot_, this->enable_read_from_follower); + if (this->common_ref().has_value()) { + xfer += prot_->serializedFieldSize("common", apache::thrift::protocol::T_STRUCT, 11); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::RequestCommon>::serializedSize(*prot_, this->common); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ScanVertexRequest::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("ScanVertexRequest"); + xfer += prot_->writeFieldBegin("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::write(*prot_, this->space_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("part_id", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::PartitionID>::write(*prot_, this->part_id); + xfer += prot_->writeFieldEnd(); + if (this->cursor_ref().has_value()) { + xfer += prot_->writeFieldBegin("cursor", apache::thrift::protocol::T_STRING, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->cursor); + xfer += prot_->writeFieldEnd(); + } + xfer += prot_->writeFieldBegin("return_columns", apache::thrift::protocol::T_STRUCT, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::VertexProp>::write(*prot_, this->return_columns); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("limit", apache::thrift::protocol::T_I64, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::write(*prot_, this->limit); + xfer += prot_->writeFieldEnd(); + if (this->start_time_ref().has_value()) { + xfer += prot_->writeFieldBegin("start_time", apache::thrift::protocol::T_I64, 6); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::write(*prot_, this->start_time); + xfer += prot_->writeFieldEnd(); + } + if (this->end_time_ref().has_value()) { + xfer += prot_->writeFieldBegin("end_time", apache::thrift::protocol::T_I64, 7); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::write(*prot_, this->end_time); + xfer += prot_->writeFieldEnd(); + } + if (this->filter_ref().has_value()) { + xfer += prot_->writeFieldBegin("filter", apache::thrift::protocol::T_STRING, 8); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->filter); + xfer += prot_->writeFieldEnd(); + } + xfer += prot_->writeFieldBegin("only_latest_version", apache::thrift::protocol::T_BOOL, 9); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::write(*prot_, this->only_latest_version); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("enable_read_from_follower", apache::thrift::protocol::T_BOOL, 10); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::write(*prot_, this->enable_read_from_follower); + xfer += prot_->writeFieldEnd(); + if (this->common_ref().has_value()) { + xfer += prot_->writeFieldBegin("common", apache::thrift::protocol::T_STRUCT, 11); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::RequestCommon>::write(*prot_, this->common); + xfer += prot_->writeFieldEnd(); + } + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void ScanVertexRequest::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t ScanVertexRequest::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t ScanVertexRequest::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t ScanVertexRequest::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void ScanVertexRequest::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t ScanVertexRequest::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t ScanVertexRequest::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t ScanVertexRequest::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { + +template +void ScanVertexResponse::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_result: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::ResponseCommon>::readWithContext(*iprot, this->result, _readState); + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_vertex_data: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::DataSet>::readWithContext(*iprot, this->vertex_data, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.vertex_data = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_BOOL))) { + goto _loop; + } +_readField_has_next: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::readWithContext(*iprot, this->has_next, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.has_next = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 4, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_next_cursor: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->next_cursor, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.next_cursor = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 4, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_result; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_vertex_data; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_BOOL))) { + goto _readField_has_next; + } else { + goto _skip; + } + } + case 4: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_next_cursor; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t ScanVertexResponse::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ScanVertexResponse"); + xfer += prot_->serializedFieldSize("result", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::ResponseCommon>::serializedSize(*prot_, this->result); + xfer += prot_->serializedFieldSize("vertex_data", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::DataSet>::serializedSize(*prot_, this->vertex_data); + xfer += prot_->serializedFieldSize("has_next", apache::thrift::protocol::T_BOOL, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::serializedSize(*prot_, this->has_next); + if (this->next_cursor_ref().has_value()) { + xfer += prot_->serializedFieldSize("next_cursor", apache::thrift::protocol::T_STRING, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->next_cursor); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ScanVertexResponse::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ScanVertexResponse"); + xfer += prot_->serializedFieldSize("result", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::ResponseCommon>::serializedSize(*prot_, this->result); + xfer += prot_->serializedFieldSize("vertex_data", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::DataSet>::serializedSize(*prot_, this->vertex_data); + xfer += prot_->serializedFieldSize("has_next", apache::thrift::protocol::T_BOOL, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::serializedSize(*prot_, this->has_next); + if (this->next_cursor_ref().has_value()) { + xfer += prot_->serializedFieldSize("next_cursor", apache::thrift::protocol::T_STRING, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->next_cursor); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ScanVertexResponse::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("ScanVertexResponse"); + xfer += prot_->writeFieldBegin("result", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::ResponseCommon>::write(*prot_, this->result); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("vertex_data", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::DataSet>::write(*prot_, this->vertex_data); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("has_next", apache::thrift::protocol::T_BOOL, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::write(*prot_, this->has_next); + xfer += prot_->writeFieldEnd(); + if (this->next_cursor_ref().has_value()) { + xfer += prot_->writeFieldBegin("next_cursor", apache::thrift::protocol::T_STRING, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->next_cursor); + xfer += prot_->writeFieldEnd(); + } + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void ScanVertexResponse::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t ScanVertexResponse::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t ScanVertexResponse::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t ScanVertexResponse::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void ScanVertexResponse::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t ScanVertexResponse::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t ScanVertexResponse::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t ScanVertexResponse::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { + +template +void ScanEdgeRequest::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_space_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::readWithContext(*iprot, this->space_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.space_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_part_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::PartitionID>::readWithContext(*iprot, this->part_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.part_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_cursor: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->cursor, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.cursor = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 4, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_return_columns: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::EdgeProp>::readWithContext(*iprot, this->return_columns, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.return_columns = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 4, + 5, + apache::thrift::protocol::T_I64))) { + goto _loop; + } +_readField_limit: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::readWithContext(*iprot, this->limit, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.limit = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 5, + 6, + apache::thrift::protocol::T_I64))) { + goto _loop; + } +_readField_start_time: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::readWithContext(*iprot, this->start_time, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.start_time = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 6, + 7, + apache::thrift::protocol::T_I64))) { + goto _loop; + } +_readField_end_time: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::readWithContext(*iprot, this->end_time, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.end_time = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 7, + 8, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_filter: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->filter, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.filter = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 8, + 9, + apache::thrift::protocol::T_BOOL))) { + goto _loop; + } +_readField_only_latest_version: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::readWithContext(*iprot, this->only_latest_version, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.only_latest_version = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 9, + 10, + apache::thrift::protocol::T_BOOL))) { + goto _loop; + } +_readField_enable_read_from_follower: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::readWithContext(*iprot, this->enable_read_from_follower, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.enable_read_from_follower = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 10, + 11, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_common: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::RequestCommon>::readWithContext(*iprot, this->common, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.common = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 11, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_space_id; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_part_id; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_cursor; + } else { + goto _skip; + } + } + case 4: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_return_columns; + } else { + goto _skip; + } + } + case 5: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I64))) { + goto _readField_limit; + } else { + goto _skip; + } + } + case 6: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I64))) { + goto _readField_start_time; + } else { + goto _skip; + } + } + case 7: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I64))) { + goto _readField_end_time; + } else { + goto _skip; + } + } + case 8: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_filter; + } else { + goto _skip; + } + } + case 9: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_BOOL))) { + goto _readField_only_latest_version; + } else { + goto _skip; + } + } + case 10: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_BOOL))) { + goto _readField_enable_read_from_follower; + } else { + goto _skip; + } + } + case 11: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_common; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t ScanEdgeRequest::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ScanEdgeRequest"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("part_id", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::PartitionID>::serializedSize(*prot_, this->part_id); + if (this->cursor_ref().has_value()) { + xfer += prot_->serializedFieldSize("cursor", apache::thrift::protocol::T_STRING, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->cursor); + } + xfer += prot_->serializedFieldSize("return_columns", apache::thrift::protocol::T_STRUCT, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::EdgeProp>::serializedSize(*prot_, this->return_columns); + xfer += prot_->serializedFieldSize("limit", apache::thrift::protocol::T_I64, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::serializedSize(*prot_, this->limit); + if (this->start_time_ref().has_value()) { + xfer += prot_->serializedFieldSize("start_time", apache::thrift::protocol::T_I64, 6); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::serializedSize(*prot_, this->start_time); + } + if (this->end_time_ref().has_value()) { + xfer += prot_->serializedFieldSize("end_time", apache::thrift::protocol::T_I64, 7); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::serializedSize(*prot_, this->end_time); + } + if (this->filter_ref().has_value()) { + xfer += prot_->serializedFieldSize("filter", apache::thrift::protocol::T_STRING, 8); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->filter); + } + xfer += prot_->serializedFieldSize("only_latest_version", apache::thrift::protocol::T_BOOL, 9); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::serializedSize(*prot_, this->only_latest_version); + xfer += prot_->serializedFieldSize("enable_read_from_follower", apache::thrift::protocol::T_BOOL, 10); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::serializedSize(*prot_, this->enable_read_from_follower); + if (this->common_ref().has_value()) { + xfer += prot_->serializedFieldSize("common", apache::thrift::protocol::T_STRUCT, 11); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::RequestCommon>::serializedSize(*prot_, this->common); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ScanEdgeRequest::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ScanEdgeRequest"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("part_id", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::PartitionID>::serializedSize(*prot_, this->part_id); + if (this->cursor_ref().has_value()) { + xfer += prot_->serializedFieldSize("cursor", apache::thrift::protocol::T_STRING, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->cursor); + } + xfer += prot_->serializedFieldSize("return_columns", apache::thrift::protocol::T_STRUCT, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::EdgeProp>::serializedSize(*prot_, this->return_columns); + xfer += prot_->serializedFieldSize("limit", apache::thrift::protocol::T_I64, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::serializedSize(*prot_, this->limit); + if (this->start_time_ref().has_value()) { + xfer += prot_->serializedFieldSize("start_time", apache::thrift::protocol::T_I64, 6); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::serializedSize(*prot_, this->start_time); + } + if (this->end_time_ref().has_value()) { + xfer += prot_->serializedFieldSize("end_time", apache::thrift::protocol::T_I64, 7); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::serializedSize(*prot_, this->end_time); + } + if (this->filter_ref().has_value()) { + xfer += prot_->serializedFieldSize("filter", apache::thrift::protocol::T_STRING, 8); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->filter); + } + xfer += prot_->serializedFieldSize("only_latest_version", apache::thrift::protocol::T_BOOL, 9); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::serializedSize(*prot_, this->only_latest_version); + xfer += prot_->serializedFieldSize("enable_read_from_follower", apache::thrift::protocol::T_BOOL, 10); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::serializedSize(*prot_, this->enable_read_from_follower); + if (this->common_ref().has_value()) { + xfer += prot_->serializedFieldSize("common", apache::thrift::protocol::T_STRUCT, 11); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::RequestCommon>::serializedSize(*prot_, this->common); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ScanEdgeRequest::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("ScanEdgeRequest"); + xfer += prot_->writeFieldBegin("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::write(*prot_, this->space_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("part_id", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::PartitionID>::write(*prot_, this->part_id); + xfer += prot_->writeFieldEnd(); + if (this->cursor_ref().has_value()) { + xfer += prot_->writeFieldBegin("cursor", apache::thrift::protocol::T_STRING, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->cursor); + xfer += prot_->writeFieldEnd(); + } + xfer += prot_->writeFieldBegin("return_columns", apache::thrift::protocol::T_STRUCT, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::EdgeProp>::write(*prot_, this->return_columns); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("limit", apache::thrift::protocol::T_I64, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::write(*prot_, this->limit); + xfer += prot_->writeFieldEnd(); + if (this->start_time_ref().has_value()) { + xfer += prot_->writeFieldBegin("start_time", apache::thrift::protocol::T_I64, 6); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::write(*prot_, this->start_time); + xfer += prot_->writeFieldEnd(); + } + if (this->end_time_ref().has_value()) { + xfer += prot_->writeFieldBegin("end_time", apache::thrift::protocol::T_I64, 7); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::write(*prot_, this->end_time); + xfer += prot_->writeFieldEnd(); + } + if (this->filter_ref().has_value()) { + xfer += prot_->writeFieldBegin("filter", apache::thrift::protocol::T_STRING, 8); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->filter); + xfer += prot_->writeFieldEnd(); + } + xfer += prot_->writeFieldBegin("only_latest_version", apache::thrift::protocol::T_BOOL, 9); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::write(*prot_, this->only_latest_version); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("enable_read_from_follower", apache::thrift::protocol::T_BOOL, 10); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::write(*prot_, this->enable_read_from_follower); + xfer += prot_->writeFieldEnd(); + if (this->common_ref().has_value()) { + xfer += prot_->writeFieldBegin("common", apache::thrift::protocol::T_STRUCT, 11); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::RequestCommon>::write(*prot_, this->common); + xfer += prot_->writeFieldEnd(); + } + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void ScanEdgeRequest::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t ScanEdgeRequest::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t ScanEdgeRequest::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t ScanEdgeRequest::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void ScanEdgeRequest::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t ScanEdgeRequest::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t ScanEdgeRequest::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t ScanEdgeRequest::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { + +template +void ScanEdgeResponse::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_result: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::ResponseCommon>::readWithContext(*iprot, this->result, _readState); + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_edge_data: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::DataSet>::readWithContext(*iprot, this->edge_data, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.edge_data = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_BOOL))) { + goto _loop; + } +_readField_has_next: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::readWithContext(*iprot, this->has_next, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.has_next = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 4, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_next_cursor: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->next_cursor, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.next_cursor = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 4, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_result; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_edge_data; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_BOOL))) { + goto _readField_has_next; + } else { + goto _skip; + } + } + case 4: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_next_cursor; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t ScanEdgeResponse::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ScanEdgeResponse"); + xfer += prot_->serializedFieldSize("result", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::ResponseCommon>::serializedSize(*prot_, this->result); + xfer += prot_->serializedFieldSize("edge_data", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::DataSet>::serializedSize(*prot_, this->edge_data); + xfer += prot_->serializedFieldSize("has_next", apache::thrift::protocol::T_BOOL, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::serializedSize(*prot_, this->has_next); + if (this->next_cursor_ref().has_value()) { + xfer += prot_->serializedFieldSize("next_cursor", apache::thrift::protocol::T_STRING, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->next_cursor); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ScanEdgeResponse::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ScanEdgeResponse"); + xfer += prot_->serializedFieldSize("result", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::ResponseCommon>::serializedSize(*prot_, this->result); + xfer += prot_->serializedFieldSize("edge_data", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::DataSet>::serializedSize(*prot_, this->edge_data); + xfer += prot_->serializedFieldSize("has_next", apache::thrift::protocol::T_BOOL, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::serializedSize(*prot_, this->has_next); + if (this->next_cursor_ref().has_value()) { + xfer += prot_->serializedFieldSize("next_cursor", apache::thrift::protocol::T_STRING, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->next_cursor); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ScanEdgeResponse::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("ScanEdgeResponse"); + xfer += prot_->writeFieldBegin("result", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::ResponseCommon>::write(*prot_, this->result); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("edge_data", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::DataSet>::write(*prot_, this->edge_data); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("has_next", apache::thrift::protocol::T_BOOL, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::write(*prot_, this->has_next); + xfer += prot_->writeFieldEnd(); + if (this->next_cursor_ref().has_value()) { + xfer += prot_->writeFieldBegin("next_cursor", apache::thrift::protocol::T_STRING, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->next_cursor); + xfer += prot_->writeFieldEnd(); + } + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void ScanEdgeResponse::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t ScanEdgeResponse::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t ScanEdgeResponse::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t ScanEdgeResponse::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void ScanEdgeResponse::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t ScanEdgeResponse::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t ScanEdgeResponse::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t ScanEdgeResponse::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { + +template +void TaskPara::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_space_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::readWithContext(*iprot, this->space_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.space_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_parts: + { + _readState.beforeSubobject(iprot); + this->parts = ::std::vector< ::nebula::cpp2::PartitionID>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::integral>, ::std::vector< ::nebula::cpp2::PartitionID>>::readWithContext(*iprot, this->parts, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.parts = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_task_specfic_paras: + { + _readState.beforeSubobject(iprot); + this->task_specfic_paras = ::std::vector<::std::string>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>, ::std::vector<::std::string>>::readWithContext(*iprot, this->task_specfic_paras, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.task_specfic_paras = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_space_id; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_parts; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_task_specfic_paras; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t TaskPara::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("TaskPara"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + if (this->parts_ref().has_value()) { + xfer += prot_->serializedFieldSize("parts", apache::thrift::protocol::T_LIST, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::integral>, ::std::vector< ::nebula::cpp2::PartitionID>>::serializedSize(*prot_, this->parts); + } + if (this->task_specfic_paras_ref().has_value()) { + xfer += prot_->serializedFieldSize("task_specfic_paras", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>, ::std::vector<::std::string>>::serializedSize(*prot_, this->task_specfic_paras); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t TaskPara::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("TaskPara"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + if (this->parts_ref().has_value()) { + xfer += prot_->serializedFieldSize("parts", apache::thrift::protocol::T_LIST, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::integral>, ::std::vector< ::nebula::cpp2::PartitionID>>::serializedSize(*prot_, this->parts); + } + if (this->task_specfic_paras_ref().has_value()) { + xfer += prot_->serializedFieldSize("task_specfic_paras", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>, ::std::vector<::std::string>>::serializedSize(*prot_, this->task_specfic_paras); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t TaskPara::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("TaskPara"); + xfer += prot_->writeFieldBegin("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::write(*prot_, this->space_id); + xfer += prot_->writeFieldEnd(); + if (this->parts_ref().has_value()) { + xfer += prot_->writeFieldBegin("parts", apache::thrift::protocol::T_LIST, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::integral>, ::std::vector< ::nebula::cpp2::PartitionID>>::write(*prot_, this->parts); + xfer += prot_->writeFieldEnd(); + } + if (this->task_specfic_paras_ref().has_value()) { + xfer += prot_->writeFieldBegin("task_specfic_paras", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>, ::std::vector<::std::string>>::write(*prot_, this->task_specfic_paras); + xfer += prot_->writeFieldEnd(); + } + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void TaskPara::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t TaskPara::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t TaskPara::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t TaskPara::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void TaskPara::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t TaskPara::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t TaskPara::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t TaskPara::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { + +template +void AddAdminTaskRequest::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_cmd: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::AdminCmd>::readWithContext(*iprot, this->cmd, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.cmd = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_job_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::readWithContext(*iprot, this->job_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.job_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_task_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::readWithContext(*iprot, this->task_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.task_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 4, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_para: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::TaskPara>::readWithContext(*iprot, this->para, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.para = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 4, + 5, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_concurrency: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::readWithContext(*iprot, this->concurrency, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.concurrency = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 5, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_cmd; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_job_id; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_task_id; + } else { + goto _skip; + } + } + case 4: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_para; + } else { + goto _skip; + } + } + case 5: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_concurrency; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t AddAdminTaskRequest::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("AddAdminTaskRequest"); + xfer += prot_->serializedFieldSize("cmd", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::AdminCmd>::serializedSize(*prot_, this->cmd); + xfer += prot_->serializedFieldSize("job_id", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::serializedSize(*prot_, this->job_id); + xfer += prot_->serializedFieldSize("task_id", apache::thrift::protocol::T_I32, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::serializedSize(*prot_, this->task_id); + xfer += prot_->serializedFieldSize("para", apache::thrift::protocol::T_STRUCT, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::TaskPara>::serializedSize(*prot_, this->para); + if (this->concurrency_ref().has_value()) { + xfer += prot_->serializedFieldSize("concurrency", apache::thrift::protocol::T_I32, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::serializedSize(*prot_, this->concurrency); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t AddAdminTaskRequest::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("AddAdminTaskRequest"); + xfer += prot_->serializedFieldSize("cmd", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::AdminCmd>::serializedSize(*prot_, this->cmd); + xfer += prot_->serializedFieldSize("job_id", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::serializedSize(*prot_, this->job_id); + xfer += prot_->serializedFieldSize("task_id", apache::thrift::protocol::T_I32, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::serializedSize(*prot_, this->task_id); + xfer += prot_->serializedFieldSize("para", apache::thrift::protocol::T_STRUCT, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::TaskPara>::serializedSize(*prot_, this->para); + if (this->concurrency_ref().has_value()) { + xfer += prot_->serializedFieldSize("concurrency", apache::thrift::protocol::T_I32, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::serializedSize(*prot_, this->concurrency); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t AddAdminTaskRequest::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("AddAdminTaskRequest"); + xfer += prot_->writeFieldBegin("cmd", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::meta::cpp2::AdminCmd>::write(*prot_, this->cmd); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("job_id", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::write(*prot_, this->job_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("task_id", apache::thrift::protocol::T_I32, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::write(*prot_, this->task_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("para", apache::thrift::protocol::T_STRUCT, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::TaskPara>::write(*prot_, this->para); + xfer += prot_->writeFieldEnd(); + if (this->concurrency_ref().has_value()) { + xfer += prot_->writeFieldBegin("concurrency", apache::thrift::protocol::T_I32, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::write(*prot_, this->concurrency); + xfer += prot_->writeFieldEnd(); + } + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void AddAdminTaskRequest::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t AddAdminTaskRequest::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t AddAdminTaskRequest::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t AddAdminTaskRequest::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void AddAdminTaskRequest::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t AddAdminTaskRequest::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t AddAdminTaskRequest::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t AddAdminTaskRequest::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { + +template +void StopAdminTaskRequest::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_job_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::readWithContext(*iprot, this->job_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.job_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_task_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::readWithContext(*iprot, this->task_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.task_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_job_id; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_task_id; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t StopAdminTaskRequest::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("StopAdminTaskRequest"); + xfer += prot_->serializedFieldSize("job_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::serializedSize(*prot_, this->job_id); + xfer += prot_->serializedFieldSize("task_id", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::serializedSize(*prot_, this->task_id); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t StopAdminTaskRequest::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("StopAdminTaskRequest"); + xfer += prot_->serializedFieldSize("job_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::serializedSize(*prot_, this->job_id); + xfer += prot_->serializedFieldSize("task_id", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::serializedSize(*prot_, this->task_id); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t StopAdminTaskRequest::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("StopAdminTaskRequest"); + xfer += prot_->writeFieldBegin("job_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::write(*prot_, this->job_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("task_id", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int32_t>::write(*prot_, this->task_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void StopAdminTaskRequest::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t StopAdminTaskRequest::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t StopAdminTaskRequest::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t StopAdminTaskRequest::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void StopAdminTaskRequest::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t StopAdminTaskRequest::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t StopAdminTaskRequest::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t StopAdminTaskRequest::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { + +template +void AdminExecResp::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_result: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::ResponseCommon>::readWithContext(*iprot, this->result, _readState); + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_stats: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::StatsItem>::readWithContext(*iprot, this->stats, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.stats = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_result; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_stats; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t AdminExecResp::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("AdminExecResp"); + xfer += prot_->serializedFieldSize("result", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::ResponseCommon>::serializedSize(*prot_, this->result); + if (this->stats_ref().has_value()) { + xfer += prot_->serializedFieldSize("stats", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::StatsItem>::serializedSize(*prot_, this->stats); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t AdminExecResp::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("AdminExecResp"); + xfer += prot_->serializedFieldSize("result", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::ResponseCommon>::serializedSize(*prot_, this->result); + if (this->stats_ref().has_value()) { + xfer += prot_->serializedFieldSize("stats", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::StatsItem>::serializedSize(*prot_, this->stats); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t AdminExecResp::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("AdminExecResp"); + xfer += prot_->writeFieldBegin("result", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::ResponseCommon>::write(*prot_, this->result); + xfer += prot_->writeFieldEnd(); + if (this->stats_ref().has_value()) { + xfer += prot_->writeFieldBegin("stats", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::meta::cpp2::StatsItem>::write(*prot_, this->stats); + xfer += prot_->writeFieldEnd(); + } + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void AdminExecResp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t AdminExecResp::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t AdminExecResp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t AdminExecResp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void AdminExecResp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t AdminExecResp::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t AdminExecResp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t AdminExecResp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { + +template +void TransLeaderReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_space_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::readWithContext(*iprot, this->space_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.space_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_part_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::PartitionID>::readWithContext(*iprot, this->part_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.part_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_new_leader: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::readWithContext(*iprot, this->new_leader, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.new_leader = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_space_id; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_part_id; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_new_leader; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t TransLeaderReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("TransLeaderReq"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("part_id", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::PartitionID>::serializedSize(*prot_, this->part_id); + xfer += prot_->serializedFieldSize("new_leader", apache::thrift::protocol::T_STRUCT, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->new_leader); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t TransLeaderReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("TransLeaderReq"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("part_id", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::PartitionID>::serializedSize(*prot_, this->part_id); + xfer += prot_->serializedFieldSize("new_leader", apache::thrift::protocol::T_STRUCT, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->new_leader); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t TransLeaderReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("TransLeaderReq"); + xfer += prot_->writeFieldBegin("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::write(*prot_, this->space_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("part_id", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::PartitionID>::write(*prot_, this->part_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("new_leader", apache::thrift::protocol::T_STRUCT, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::write(*prot_, this->new_leader); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void TransLeaderReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t TransLeaderReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t TransLeaderReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t TransLeaderReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void TransLeaderReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t TransLeaderReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t TransLeaderReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t TransLeaderReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { + +template +void AddPartReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_space_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::readWithContext(*iprot, this->space_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.space_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_part_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::PartitionID>::readWithContext(*iprot, this->part_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.part_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_BOOL))) { + goto _loop; + } +_readField_as_learner: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::readWithContext(*iprot, this->as_learner, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.as_learner = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 4, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_peers: + { + _readState.beforeSubobject(iprot); + this->peers = ::std::vector(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector>::readWithContext(*iprot, this->peers, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.peers = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 4, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_space_id; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_part_id; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_BOOL))) { + goto _readField_as_learner; + } else { + goto _skip; + } + } + case 4: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_peers; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t AddPartReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("AddPartReq"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("part_id", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::PartitionID>::serializedSize(*prot_, this->part_id); + xfer += prot_->serializedFieldSize("as_learner", apache::thrift::protocol::T_BOOL, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::serializedSize(*prot_, this->as_learner); + xfer += prot_->serializedFieldSize("peers", apache::thrift::protocol::T_LIST, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector>::serializedSize(*prot_, this->peers); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t AddPartReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("AddPartReq"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("part_id", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::PartitionID>::serializedSize(*prot_, this->part_id); + xfer += prot_->serializedFieldSize("as_learner", apache::thrift::protocol::T_BOOL, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::serializedSize(*prot_, this->as_learner); + xfer += prot_->serializedFieldSize("peers", apache::thrift::protocol::T_LIST, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector>::serializedSize(*prot_, this->peers); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t AddPartReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("AddPartReq"); + xfer += prot_->writeFieldBegin("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::write(*prot_, this->space_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("part_id", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::PartitionID>::write(*prot_, this->part_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("as_learner", apache::thrift::protocol::T_BOOL, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::write(*prot_, this->as_learner); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("peers", apache::thrift::protocol::T_LIST, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector>::write(*prot_, this->peers); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void AddPartReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t AddPartReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t AddPartReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t AddPartReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void AddPartReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t AddPartReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t AddPartReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t AddPartReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { + +template +void AddLearnerReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_space_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::readWithContext(*iprot, this->space_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.space_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_part_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::PartitionID>::readWithContext(*iprot, this->part_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.part_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_learner: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::readWithContext(*iprot, this->learner, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.learner = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_space_id; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_part_id; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_learner; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t AddLearnerReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("AddLearnerReq"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("part_id", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::PartitionID>::serializedSize(*prot_, this->part_id); + xfer += prot_->serializedFieldSize("learner", apache::thrift::protocol::T_STRUCT, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->learner); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t AddLearnerReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("AddLearnerReq"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("part_id", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::PartitionID>::serializedSize(*prot_, this->part_id); + xfer += prot_->serializedFieldSize("learner", apache::thrift::protocol::T_STRUCT, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->learner); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t AddLearnerReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("AddLearnerReq"); + xfer += prot_->writeFieldBegin("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::write(*prot_, this->space_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("part_id", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::PartitionID>::write(*prot_, this->part_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("learner", apache::thrift::protocol::T_STRUCT, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::write(*prot_, this->learner); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void AddLearnerReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t AddLearnerReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t AddLearnerReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t AddLearnerReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void AddLearnerReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t AddLearnerReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t AddLearnerReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t AddLearnerReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { + +template +void RemovePartReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_space_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::readWithContext(*iprot, this->space_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.space_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_part_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::PartitionID>::readWithContext(*iprot, this->part_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.part_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_space_id; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_part_id; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t RemovePartReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("RemovePartReq"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("part_id", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::PartitionID>::serializedSize(*prot_, this->part_id); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t RemovePartReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("RemovePartReq"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("part_id", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::PartitionID>::serializedSize(*prot_, this->part_id); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t RemovePartReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("RemovePartReq"); + xfer += prot_->writeFieldBegin("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::write(*prot_, this->space_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("part_id", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::PartitionID>::write(*prot_, this->part_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void RemovePartReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t RemovePartReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t RemovePartReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t RemovePartReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void RemovePartReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t RemovePartReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t RemovePartReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t RemovePartReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { + +template +void MemberChangeReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_space_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::readWithContext(*iprot, this->space_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.space_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_part_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::PartitionID>::readWithContext(*iprot, this->part_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.part_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_peer: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::readWithContext(*iprot, this->peer, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.peer = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 4, + apache::thrift::protocol::T_BOOL))) { + goto _loop; + } +_readField_add: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::readWithContext(*iprot, this->add, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.add = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 4, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_space_id; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_part_id; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_peer; + } else { + goto _skip; + } + } + case 4: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_BOOL))) { + goto _readField_add; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t MemberChangeReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("MemberChangeReq"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("part_id", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::PartitionID>::serializedSize(*prot_, this->part_id); + xfer += prot_->serializedFieldSize("peer", apache::thrift::protocol::T_STRUCT, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->peer); + xfer += prot_->serializedFieldSize("add", apache::thrift::protocol::T_BOOL, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::serializedSize(*prot_, this->add); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t MemberChangeReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("MemberChangeReq"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("part_id", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::PartitionID>::serializedSize(*prot_, this->part_id); + xfer += prot_->serializedFieldSize("peer", apache::thrift::protocol::T_STRUCT, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->peer); + xfer += prot_->serializedFieldSize("add", apache::thrift::protocol::T_BOOL, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::serializedSize(*prot_, this->add); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t MemberChangeReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("MemberChangeReq"); + xfer += prot_->writeFieldBegin("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::write(*prot_, this->space_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("part_id", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::PartitionID>::write(*prot_, this->part_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("peer", apache::thrift::protocol::T_STRUCT, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::write(*prot_, this->peer); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("add", apache::thrift::protocol::T_BOOL, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::write(*prot_, this->add); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void MemberChangeReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t MemberChangeReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t MemberChangeReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t MemberChangeReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void MemberChangeReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t MemberChangeReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t MemberChangeReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t MemberChangeReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { + +template +void CatchUpDataReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_space_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::readWithContext(*iprot, this->space_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.space_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_part_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::PartitionID>::readWithContext(*iprot, this->part_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.part_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_target: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::readWithContext(*iprot, this->target, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.target = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_space_id; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_part_id; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_target; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t CatchUpDataReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("CatchUpDataReq"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("part_id", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::PartitionID>::serializedSize(*prot_, this->part_id); + xfer += prot_->serializedFieldSize("target", apache::thrift::protocol::T_STRUCT, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->target); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t CatchUpDataReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("CatchUpDataReq"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("part_id", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::PartitionID>::serializedSize(*prot_, this->part_id); + xfer += prot_->serializedFieldSize("target", apache::thrift::protocol::T_STRUCT, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::serializedSize(*prot_, this->target); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t CatchUpDataReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("CatchUpDataReq"); + xfer += prot_->writeFieldBegin("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::write(*prot_, this->space_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("part_id", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::PartitionID>::write(*prot_, this->part_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("target", apache::thrift::protocol::T_STRUCT, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, nebula::HostAddr>::write(*prot_, this->target); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void CatchUpDataReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t CatchUpDataReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t CatchUpDataReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t CatchUpDataReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void CatchUpDataReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t CatchUpDataReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t CatchUpDataReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t CatchUpDataReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { + +template +void GetLeaderReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + default: + { + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t GetLeaderReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("GetLeaderReq"); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t GetLeaderReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("GetLeaderReq"); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t GetLeaderReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("GetLeaderReq"); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void GetLeaderReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t GetLeaderReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t GetLeaderReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t GetLeaderReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void GetLeaderReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t GetLeaderReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t GetLeaderReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t GetLeaderReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { + +template +void CreateCPRequest::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_space_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::readWithContext(*iprot, this->space_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.space_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_name: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->name, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.name = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_space_id; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_name; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t CreateCPRequest::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("CreateCPRequest"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("name", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->name); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t CreateCPRequest::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("CreateCPRequest"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("name", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->name); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t CreateCPRequest::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("CreateCPRequest"); + xfer += prot_->writeFieldBegin("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::write(*prot_, this->space_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("name", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->name); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void CreateCPRequest::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t CreateCPRequest::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t CreateCPRequest::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t CreateCPRequest::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void CreateCPRequest::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t CreateCPRequest::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t CreateCPRequest::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t CreateCPRequest::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { + +template +void DropCPRequest::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_space_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::readWithContext(*iprot, this->space_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.space_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRING))) { + goto _loop; + } +_readField_name: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::readWithContext(*iprot, this->name, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.name = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_space_id; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRING))) { + goto _readField_name; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t DropCPRequest::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("DropCPRequest"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("name", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->name); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t DropCPRequest::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("DropCPRequest"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("name", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::serializedSize(*prot_, this->name); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t DropCPRequest::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("DropCPRequest"); + xfer += prot_->writeFieldBegin("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::write(*prot_, this->space_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("name", apache::thrift::protocol::T_STRING, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::binary, ::std::string>::write(*prot_, this->name); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void DropCPRequest::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t DropCPRequest::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t DropCPRequest::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t DropCPRequest::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void DropCPRequest::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t DropCPRequest::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t DropCPRequest::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t DropCPRequest::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { + +template +void BlockingSignRequest::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_space_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::readWithContext(*iprot, this->space_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.space_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_sign: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::storage::cpp2::EngineSignType>::readWithContext(*iprot, this->sign, _readState); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_space_id; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_sign; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t BlockingSignRequest::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("BlockingSignRequest"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("sign", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::storage::cpp2::EngineSignType>::serializedSize(*prot_, this->sign); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t BlockingSignRequest::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("BlockingSignRequest"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("sign", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::storage::cpp2::EngineSignType>::serializedSize(*prot_, this->sign); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t BlockingSignRequest::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("BlockingSignRequest"); + xfer += prot_->writeFieldBegin("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::write(*prot_, this->space_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("sign", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::enumeration, ::nebula::storage::cpp2::EngineSignType>::write(*prot_, this->sign); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void BlockingSignRequest::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t BlockingSignRequest::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t BlockingSignRequest::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t BlockingSignRequest::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void BlockingSignRequest::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t BlockingSignRequest::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t BlockingSignRequest::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t BlockingSignRequest::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { + +template +void GetLeaderPartsResp::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_result: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::ResponseCommon>::readWithContext(*iprot, this->result, _readState); + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_MAP))) { + goto _loop; + } +_readField_leader_parts: + { + _readState.beforeSubobject(iprot); + this->leader_parts = std::unordered_map< ::nebula::cpp2::GraphSpaceID, ::std::vector< ::nebula::cpp2::PartitionID>>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::integral>>, std::unordered_map< ::nebula::cpp2::GraphSpaceID, ::std::vector< ::nebula::cpp2::PartitionID>>>::readWithContext(*iprot, this->leader_parts, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.leader_parts = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_result; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_MAP))) { + goto _readField_leader_parts; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t GetLeaderPartsResp::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("GetLeaderPartsResp"); + xfer += prot_->serializedFieldSize("result", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::ResponseCommon>::serializedSize(*prot_, this->result); + xfer += prot_->serializedFieldSize("leader_parts", apache::thrift::protocol::T_MAP, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::integral>>, std::unordered_map< ::nebula::cpp2::GraphSpaceID, ::std::vector< ::nebula::cpp2::PartitionID>>>::serializedSize(*prot_, this->leader_parts); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t GetLeaderPartsResp::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("GetLeaderPartsResp"); + xfer += prot_->serializedFieldSize("result", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::ResponseCommon>::serializedSize(*prot_, this->result); + xfer += prot_->serializedFieldSize("leader_parts", apache::thrift::protocol::T_MAP, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::integral>>, std::unordered_map< ::nebula::cpp2::GraphSpaceID, ::std::vector< ::nebula::cpp2::PartitionID>>>::serializedSize(*prot_, this->leader_parts); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t GetLeaderPartsResp::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("GetLeaderPartsResp"); + xfer += prot_->writeFieldBegin("result", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::ResponseCommon>::write(*prot_, this->result); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("leader_parts", apache::thrift::protocol::T_MAP, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::integral>>, std::unordered_map< ::nebula::cpp2::GraphSpaceID, ::std::vector< ::nebula::cpp2::PartitionID>>>::write(*prot_, this->leader_parts); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void GetLeaderPartsResp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t GetLeaderPartsResp::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t GetLeaderPartsResp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t GetLeaderPartsResp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void GetLeaderPartsResp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t GetLeaderPartsResp::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t GetLeaderPartsResp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t GetLeaderPartsResp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { + +template +void CheckPeersReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_space_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::readWithContext(*iprot, this->space_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.space_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_part_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::PartitionID>::readWithContext(*iprot, this->part_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.part_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_peers: + { + _readState.beforeSubobject(iprot); + this->peers = ::std::vector(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector>::readWithContext(*iprot, this->peers, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.peers = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_space_id; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_part_id; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_peers; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t CheckPeersReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("CheckPeersReq"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("part_id", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::PartitionID>::serializedSize(*prot_, this->part_id); + xfer += prot_->serializedFieldSize("peers", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector>::serializedSize(*prot_, this->peers); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t CheckPeersReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("CheckPeersReq"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("part_id", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::PartitionID>::serializedSize(*prot_, this->part_id); + xfer += prot_->serializedFieldSize("peers", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector>::serializedSize(*prot_, this->peers); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t CheckPeersReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("CheckPeersReq"); + xfer += prot_->writeFieldBegin("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::write(*prot_, this->space_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("part_id", apache::thrift::protocol::T_I32, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::PartitionID>::write(*prot_, this->part_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("peers", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector>::write(*prot_, this->peers); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void CheckPeersReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t CheckPeersReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t CheckPeersReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t CheckPeersReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void CheckPeersReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t CheckPeersReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t CheckPeersReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t CheckPeersReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { + +template +void RebuildIndexRequest::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_space_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::readWithContext(*iprot, this->space_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.space_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_parts: + { + _readState.beforeSubobject(iprot); + this->parts = ::std::vector< ::nebula::cpp2::PartitionID>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::integral>, ::std::vector< ::nebula::cpp2::PartitionID>>::readWithContext(*iprot, this->parts, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.parts = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_index_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::IndexID>::readWithContext(*iprot, this->index_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.index_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_space_id; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_parts; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_index_id; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t RebuildIndexRequest::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("RebuildIndexRequest"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("parts", apache::thrift::protocol::T_LIST, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::integral>, ::std::vector< ::nebula::cpp2::PartitionID>>::serializedSize(*prot_, this->parts); + xfer += prot_->serializedFieldSize("index_id", apache::thrift::protocol::T_I32, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::IndexID>::serializedSize(*prot_, this->index_id); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t RebuildIndexRequest::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("RebuildIndexRequest"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("parts", apache::thrift::protocol::T_LIST, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::integral>, ::std::vector< ::nebula::cpp2::PartitionID>>::serializedSize(*prot_, this->parts); + xfer += prot_->serializedFieldSize("index_id", apache::thrift::protocol::T_I32, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::IndexID>::serializedSize(*prot_, this->index_id); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t RebuildIndexRequest::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("RebuildIndexRequest"); + xfer += prot_->writeFieldBegin("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::write(*prot_, this->space_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("parts", apache::thrift::protocol::T_LIST, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::integral>, ::std::vector< ::nebula::cpp2::PartitionID>>::write(*prot_, this->parts); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("index_id", apache::thrift::protocol::T_I32, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::IndexID>::write(*prot_, this->index_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void RebuildIndexRequest::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t RebuildIndexRequest::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t RebuildIndexRequest::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t RebuildIndexRequest::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void RebuildIndexRequest::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t RebuildIndexRequest::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t RebuildIndexRequest::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t RebuildIndexRequest::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { + +template +void CreateCPResp::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_result: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::ResponseCommon>::readWithContext(*iprot, this->result, _readState); + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_info: + { + _readState.beforeSubobject(iprot); + this->info = ::std::vector< ::nebula::cpp2::CheckpointInfo>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::cpp2::CheckpointInfo>>::readWithContext(*iprot, this->info, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.info = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_result; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_info; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t CreateCPResp::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("CreateCPResp"); + xfer += prot_->serializedFieldSize("result", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::ResponseCommon>::serializedSize(*prot_, this->result); + xfer += prot_->serializedFieldSize("info", apache::thrift::protocol::T_LIST, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::cpp2::CheckpointInfo>>::serializedSize(*prot_, this->info); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t CreateCPResp::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("CreateCPResp"); + xfer += prot_->serializedFieldSize("result", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::ResponseCommon>::serializedSize(*prot_, this->result); + xfer += prot_->serializedFieldSize("info", apache::thrift::protocol::T_LIST, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::cpp2::CheckpointInfo>>::serializedSize(*prot_, this->info); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t CreateCPResp::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("CreateCPResp"); + xfer += prot_->writeFieldBegin("result", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::ResponseCommon>::write(*prot_, this->result); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("info", apache::thrift::protocol::T_LIST, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>, ::std::vector< ::nebula::cpp2::CheckpointInfo>>::write(*prot_, this->info); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void CreateCPResp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t CreateCPResp::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t CreateCPResp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t CreateCPResp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void CreateCPResp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t CreateCPResp::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t CreateCPResp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t CreateCPResp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { + +template +void ListClusterInfoResp::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_result: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::ResponseCommon>::readWithContext(*iprot, this->result, _readState); + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_dir: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::cpp2::DirInfo>::readWithContext(*iprot, this->dir, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.dir = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_result; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_dir; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t ListClusterInfoResp::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ListClusterInfoResp"); + xfer += prot_->serializedFieldSize("result", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::ResponseCommon>::serializedSize(*prot_, this->result); + xfer += prot_->serializedFieldSize("dir", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::cpp2::DirInfo>::serializedSize(*prot_, this->dir); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ListClusterInfoResp::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ListClusterInfoResp"); + xfer += prot_->serializedFieldSize("result", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::ResponseCommon>::serializedSize(*prot_, this->result); + xfer += prot_->serializedFieldSize("dir", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::cpp2::DirInfo>::serializedSize(*prot_, this->dir); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ListClusterInfoResp::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("ListClusterInfoResp"); + xfer += prot_->writeFieldBegin("result", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::ResponseCommon>::write(*prot_, this->result); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("dir", apache::thrift::protocol::T_STRUCT, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::cpp2::DirInfo>::write(*prot_, this->dir); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void ListClusterInfoResp::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t ListClusterInfoResp::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t ListClusterInfoResp::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t ListClusterInfoResp::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void ListClusterInfoResp::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t ListClusterInfoResp::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t ListClusterInfoResp::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t ListClusterInfoResp::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { + +template +void ListClusterInfoReq::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + default: + { + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t ListClusterInfoReq::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ListClusterInfoReq"); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ListClusterInfoReq::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ListClusterInfoReq"); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ListClusterInfoReq::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("ListClusterInfoReq"); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void ListClusterInfoReq::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t ListClusterInfoReq::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t ListClusterInfoReq::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t ListClusterInfoReq::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void ListClusterInfoReq::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t ListClusterInfoReq::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t ListClusterInfoReq::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t ListClusterInfoReq::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { + +template +void KVGetRequest::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_space_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::readWithContext(*iprot, this->space_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.space_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_MAP))) { + goto _loop; + } +_readField_parts: + { + _readState.beforeSubobject(iprot); + this->parts = std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector<::std::string>>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>>, std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector<::std::string>>>::readWithContext(*iprot, this->parts, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.parts = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_BOOL))) { + goto _loop; + } +_readField_return_partly: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::readWithContext(*iprot, this->return_partly, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.return_partly = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_space_id; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_MAP))) { + goto _readField_parts; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_BOOL))) { + goto _readField_return_partly; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t KVGetRequest::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("KVGetRequest"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("parts", apache::thrift::protocol::T_MAP, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>>, std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector<::std::string>>>::serializedSize(*prot_, this->parts); + xfer += prot_->serializedFieldSize("return_partly", apache::thrift::protocol::T_BOOL, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::serializedSize(*prot_, this->return_partly); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t KVGetRequest::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("KVGetRequest"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("parts", apache::thrift::protocol::T_MAP, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>>, std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector<::std::string>>>::serializedSize(*prot_, this->parts); + xfer += prot_->serializedFieldSize("return_partly", apache::thrift::protocol::T_BOOL, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::serializedSize(*prot_, this->return_partly); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t KVGetRequest::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("KVGetRequest"); + xfer += prot_->writeFieldBegin("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::write(*prot_, this->space_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("parts", apache::thrift::protocol::T_MAP, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>>, std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector<::std::string>>>::write(*prot_, this->parts); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("return_partly", apache::thrift::protocol::T_BOOL, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::write(*prot_, this->return_partly); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void KVGetRequest::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t KVGetRequest::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t KVGetRequest::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t KVGetRequest::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void KVGetRequest::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t KVGetRequest::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t KVGetRequest::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t KVGetRequest::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { + +template +void KVGetResponse::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_result: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::ResponseCommon>::readWithContext(*iprot, this->result, _readState); + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_MAP))) { + goto _loop; + } +_readField_key_values: + { + _readState.beforeSubobject(iprot); + this->key_values = std::unordered_map<::std::string, ::std::string>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::binary, ::apache::thrift::type_class::binary>, std::unordered_map<::std::string, ::std::string>>::readWithContext(*iprot, this->key_values, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.key_values = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_result; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_MAP))) { + goto _readField_key_values; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t KVGetResponse::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("KVGetResponse"); + xfer += prot_->serializedFieldSize("result", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::ResponseCommon>::serializedSize(*prot_, this->result); + xfer += prot_->serializedFieldSize("key_values", apache::thrift::protocol::T_MAP, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::binary, ::apache::thrift::type_class::binary>, std::unordered_map<::std::string, ::std::string>>::serializedSize(*prot_, this->key_values); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t KVGetResponse::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("KVGetResponse"); + xfer += prot_->serializedFieldSize("result", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::ResponseCommon>::serializedSize(*prot_, this->result); + xfer += prot_->serializedFieldSize("key_values", apache::thrift::protocol::T_MAP, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::binary, ::apache::thrift::type_class::binary>, std::unordered_map<::std::string, ::std::string>>::serializedSize(*prot_, this->key_values); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t KVGetResponse::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("KVGetResponse"); + xfer += prot_->writeFieldBegin("result", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::ResponseCommon>::write(*prot_, this->result); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("key_values", apache::thrift::protocol::T_MAP, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::binary, ::apache::thrift::type_class::binary>, std::unordered_map<::std::string, ::std::string>>::write(*prot_, this->key_values); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void KVGetResponse::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t KVGetResponse::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t KVGetResponse::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t KVGetResponse::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void KVGetResponse::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t KVGetResponse::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t KVGetResponse::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t KVGetResponse::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { + +template +void KVPutRequest::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_space_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::readWithContext(*iprot, this->space_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.space_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_MAP))) { + goto _loop; + } +_readField_parts: + { + _readState.beforeSubobject(iprot); + this->parts = std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>>, std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector>>::readWithContext(*iprot, this->parts, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.parts = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_space_id; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_MAP))) { + goto _readField_parts; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t KVPutRequest::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("KVPutRequest"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("parts", apache::thrift::protocol::T_MAP, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>>, std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector>>::serializedSize(*prot_, this->parts); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t KVPutRequest::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("KVPutRequest"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("parts", apache::thrift::protocol::T_MAP, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>>, std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector>>::serializedSize(*prot_, this->parts); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t KVPutRequest::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("KVPutRequest"); + xfer += prot_->writeFieldBegin("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::write(*prot_, this->space_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("parts", apache::thrift::protocol::T_MAP, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>>, std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector>>::write(*prot_, this->parts); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void KVPutRequest::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t KVPutRequest::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t KVPutRequest::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t KVPutRequest::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void KVPutRequest::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t KVPutRequest::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t KVPutRequest::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t KVPutRequest::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { + +template +void KVRemoveRequest::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_space_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::readWithContext(*iprot, this->space_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.space_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_MAP))) { + goto _loop; + } +_readField_parts: + { + _readState.beforeSubobject(iprot); + this->parts = std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector<::std::string>>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>>, std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector<::std::string>>>::readWithContext(*iprot, this->parts, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.parts = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_space_id; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_MAP))) { + goto _readField_parts; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t KVRemoveRequest::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("KVRemoveRequest"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("parts", apache::thrift::protocol::T_MAP, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>>, std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector<::std::string>>>::serializedSize(*prot_, this->parts); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t KVRemoveRequest::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("KVRemoveRequest"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("parts", apache::thrift::protocol::T_MAP, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>>, std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector<::std::string>>>::serializedSize(*prot_, this->parts); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t KVRemoveRequest::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("KVRemoveRequest"); + xfer += prot_->writeFieldBegin("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::write(*prot_, this->space_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("parts", apache::thrift::protocol::T_MAP, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>>, std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector<::std::string>>>::write(*prot_, this->parts); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void KVRemoveRequest::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t KVRemoveRequest::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t KVRemoveRequest::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t KVRemoveRequest::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void KVRemoveRequest::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t KVRemoveRequest::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t KVRemoveRequest::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t KVRemoveRequest::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { + +template +void InternalTxnRequest::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I64))) { + goto _loop; + } +_readField_txn_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::readWithContext(*iprot, this->txn_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.txn_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_MAP))) { + goto _loop; + } +_readField_term_of_parts: + { + _readState.beforeSubobject(iprot); + this->term_of_parts = ::std::map< ::nebula::cpp2::PartitionID, int64_t>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::integral>, ::std::map< ::nebula::cpp2::PartitionID, int64_t>>::readWithContext(*iprot, this->term_of_parts, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.term_of_parts = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_add_edge_req: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::AddEdgesRequest>::readWithContext(*iprot, this->add_edge_req, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.add_edge_req = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 4, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_upd_edge_req: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::UpdateEdgeRequest>::readWithContext(*iprot, this->upd_edge_req, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.upd_edge_req = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 4, + 5, + apache::thrift::protocol::T_MAP))) { + goto _loop; + } +_readField_edge_ver: + { + _readState.beforeSubobject(iprot); + this->edge_ver = std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::integral>>, std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector>>::readWithContext(*iprot, this->edge_ver, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.edge_ver = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 5, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I64))) { + goto _readField_txn_id; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_MAP))) { + goto _readField_term_of_parts; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_add_edge_req; + } else { + goto _skip; + } + } + case 4: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_upd_edge_req; + } else { + goto _skip; + } + } + case 5: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_MAP))) { + goto _readField_edge_ver; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t InternalTxnRequest::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("InternalTxnRequest"); + xfer += prot_->serializedFieldSize("txn_id", apache::thrift::protocol::T_I64, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::serializedSize(*prot_, this->txn_id); + xfer += prot_->serializedFieldSize("term_of_parts", apache::thrift::protocol::T_MAP, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::integral>, ::std::map< ::nebula::cpp2::PartitionID, int64_t>>::serializedSize(*prot_, this->term_of_parts); + if (this->add_edge_req_ref().has_value()) { + xfer += prot_->serializedFieldSize("add_edge_req", apache::thrift::protocol::T_STRUCT, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::AddEdgesRequest>::serializedSize(*prot_, this->add_edge_req); + } + if (this->upd_edge_req_ref().has_value()) { + xfer += prot_->serializedFieldSize("upd_edge_req", apache::thrift::protocol::T_STRUCT, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::UpdateEdgeRequest>::serializedSize(*prot_, this->upd_edge_req); + } + if (this->edge_ver_ref().has_value()) { + xfer += prot_->serializedFieldSize("edge_ver", apache::thrift::protocol::T_MAP, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::integral>>, std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector>>::serializedSize(*prot_, this->edge_ver); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t InternalTxnRequest::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("InternalTxnRequest"); + xfer += prot_->serializedFieldSize("txn_id", apache::thrift::protocol::T_I64, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::serializedSize(*prot_, this->txn_id); + xfer += prot_->serializedFieldSize("term_of_parts", apache::thrift::protocol::T_MAP, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::integral>, ::std::map< ::nebula::cpp2::PartitionID, int64_t>>::serializedSize(*prot_, this->term_of_parts); + if (this->add_edge_req_ref().has_value()) { + xfer += prot_->serializedFieldSize("add_edge_req", apache::thrift::protocol::T_STRUCT, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::AddEdgesRequest>::serializedSize(*prot_, this->add_edge_req); + } + if (this->upd_edge_req_ref().has_value()) { + xfer += prot_->serializedFieldSize("upd_edge_req", apache::thrift::protocol::T_STRUCT, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::UpdateEdgeRequest>::serializedSize(*prot_, this->upd_edge_req); + } + if (this->edge_ver_ref().has_value()) { + xfer += prot_->serializedFieldSize("edge_ver", apache::thrift::protocol::T_MAP, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::integral>>, std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector>>::serializedSize(*prot_, this->edge_ver); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t InternalTxnRequest::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("InternalTxnRequest"); + xfer += prot_->writeFieldBegin("txn_id", apache::thrift::protocol::T_I64, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::write(*prot_, this->txn_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("term_of_parts", apache::thrift::protocol::T_MAP, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::integral>, ::std::map< ::nebula::cpp2::PartitionID, int64_t>>::write(*prot_, this->term_of_parts); + xfer += prot_->writeFieldEnd(); + if (this->add_edge_req_ref().has_value()) { + xfer += prot_->writeFieldBegin("add_edge_req", apache::thrift::protocol::T_STRUCT, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::AddEdgesRequest>::write(*prot_, this->add_edge_req); + xfer += prot_->writeFieldEnd(); + } + if (this->upd_edge_req_ref().has_value()) { + xfer += prot_->writeFieldBegin("upd_edge_req", apache::thrift::protocol::T_STRUCT, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::UpdateEdgeRequest>::write(*prot_, this->upd_edge_req); + xfer += prot_->writeFieldEnd(); + } + if (this->edge_ver_ref().has_value()) { + xfer += prot_->writeFieldBegin("edge_ver", apache::thrift::protocol::T_MAP, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::integral>>, std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector>>::write(*prot_, this->edge_ver); + xfer += prot_->writeFieldEnd(); + } + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void InternalTxnRequest::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t InternalTxnRequest::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t InternalTxnRequest::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t InternalTxnRequest::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void InternalTxnRequest::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t InternalTxnRequest::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t InternalTxnRequest::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t InternalTxnRequest::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { + +template +void ChainAddEdgesRequest::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_space_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::readWithContext(*iprot, this->space_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.space_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_MAP))) { + goto _loop; + } +_readField_parts: + { + _readState.beforeSubobject(iprot); + this->parts = std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::storage::cpp2::NewEdge>>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>>, std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::storage::cpp2::NewEdge>>>::readWithContext(*iprot, this->parts, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.parts = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_prop_names: + { + _readState.beforeSubobject(iprot); + this->prop_names = ::std::vector<::std::string>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>, ::std::vector<::std::string>>::readWithContext(*iprot, this->prop_names, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.prop_names = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 4, + apache::thrift::protocol::T_BOOL))) { + goto _loop; + } +_readField_if_not_exists: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::readWithContext(*iprot, this->if_not_exists, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.if_not_exists = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 4, + 5, + apache::thrift::protocol::T_I64))) { + goto _loop; + } +_readField_term: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::readWithContext(*iprot, this->term, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.term = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 5, + 6, + apache::thrift::protocol::T_I64))) { + goto _loop; + } +_readField_edge_version: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::readWithContext(*iprot, this->edge_version, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.edge_version = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 6, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_space_id; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_MAP))) { + goto _readField_parts; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_prop_names; + } else { + goto _skip; + } + } + case 4: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_BOOL))) { + goto _readField_if_not_exists; + } else { + goto _skip; + } + } + case 5: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I64))) { + goto _readField_term; + } else { + goto _skip; + } + } + case 6: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I64))) { + goto _readField_edge_version; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t ChainAddEdgesRequest::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ChainAddEdgesRequest"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("parts", apache::thrift::protocol::T_MAP, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>>, std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::storage::cpp2::NewEdge>>>::serializedSize(*prot_, this->parts); + xfer += prot_->serializedFieldSize("prop_names", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>, ::std::vector<::std::string>>::serializedSize(*prot_, this->prop_names); + xfer += prot_->serializedFieldSize("if_not_exists", apache::thrift::protocol::T_BOOL, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::serializedSize(*prot_, this->if_not_exists); + xfer += prot_->serializedFieldSize("term", apache::thrift::protocol::T_I64, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::serializedSize(*prot_, this->term); + if (this->edge_version_ref().has_value()) { + xfer += prot_->serializedFieldSize("edge_version", apache::thrift::protocol::T_I64, 6); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::serializedSize(*prot_, this->edge_version); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ChainAddEdgesRequest::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ChainAddEdgesRequest"); + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("parts", apache::thrift::protocol::T_MAP, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>>, std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::storage::cpp2::NewEdge>>>::serializedSize(*prot_, this->parts); + xfer += prot_->serializedFieldSize("prop_names", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>, ::std::vector<::std::string>>::serializedSize(*prot_, this->prop_names); + xfer += prot_->serializedFieldSize("if_not_exists", apache::thrift::protocol::T_BOOL, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::serializedSize(*prot_, this->if_not_exists); + xfer += prot_->serializedFieldSize("term", apache::thrift::protocol::T_I64, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::serializedSize(*prot_, this->term); + if (this->edge_version_ref().has_value()) { + xfer += prot_->serializedFieldSize("edge_version", apache::thrift::protocol::T_I64, 6); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::serializedSize(*prot_, this->edge_version); + } + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ChainAddEdgesRequest::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("ChainAddEdgesRequest"); + xfer += prot_->writeFieldBegin("space_id", apache::thrift::protocol::T_I32, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::write(*prot_, this->space_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("parts", apache::thrift::protocol::T_MAP, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::structure>>, std::unordered_map< ::nebula::cpp2::PartitionID, ::std::vector< ::nebula::storage::cpp2::NewEdge>>>::write(*prot_, this->parts); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("prop_names", apache::thrift::protocol::T_LIST, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::binary>, ::std::vector<::std::string>>::write(*prot_, this->prop_names); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("if_not_exists", apache::thrift::protocol::T_BOOL, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, bool>::write(*prot_, this->if_not_exists); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("term", apache::thrift::protocol::T_I64, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::write(*prot_, this->term); + xfer += prot_->writeFieldEnd(); + if (this->edge_version_ref().has_value()) { + xfer += prot_->writeFieldBegin("edge_version", apache::thrift::protocol::T_I64, 6); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::write(*prot_, this->edge_version); + xfer += prot_->writeFieldEnd(); + } + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void ChainAddEdgesRequest::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t ChainAddEdgesRequest::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t ChainAddEdgesRequest::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t ChainAddEdgesRequest::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void ChainAddEdgesRequest::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t ChainAddEdgesRequest::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t ChainAddEdgesRequest::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t ChainAddEdgesRequest::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::storage::cpp2 +namespace nebula { namespace storage { namespace cpp2 { + +template +void ChainUpdateEdgeRequest::readNoXfer(Protocol_* iprot) { + apache::thrift::detail::ProtocolReaderStructReadState _readState; + + _readState.readStructBegin(iprot); + + using apache::thrift::TProtocolException; + + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 0, + 1, + apache::thrift::protocol::T_STRUCT))) { + goto _loop; + } +_readField_update_edge_request: + { + _readState.beforeSubobject(iprot); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::UpdateEdgeRequest>::readWithContext(*iprot, this->update_edge_request, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.update_edge_request = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 1, + 2, + apache::thrift::protocol::T_I64))) { + goto _loop; + } +_readField_term: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::readWithContext(*iprot, this->term, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.term = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 2, + 3, + apache::thrift::protocol::T_I64))) { + goto _loop; + } +_readField_edge_version: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::readWithContext(*iprot, this->edge_version, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.edge_version = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 3, + 4, + apache::thrift::protocol::T_I32))) { + goto _loop; + } +_readField_space_id: + { + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::readWithContext(*iprot, this->space_id, _readState); + THRIFT_IGNORE_ISSET_USE_WARNING_BEGIN + this->__isset.space_id = true; + THRIFT_IGNORE_ISSET_USE_WARNING_END + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 4, + 5, + apache::thrift::protocol::T_LIST))) { + goto _loop; + } +_readField_parts: + { + _readState.beforeSubobject(iprot); + this->parts = ::std::vector< ::nebula::cpp2::PartitionID>(); + ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::integral>, ::std::vector< ::nebula::cpp2::PartitionID>>::readWithContext(*iprot, this->parts, _readState); + _readState.afterSubobject(iprot); + } + + if (UNLIKELY(!_readState.advanceToNextField( + iprot, + 5, + 0, + apache::thrift::protocol::T_STOP))) { + goto _loop; + } + +_end: + _readState.readStructEnd(iprot); + + return; + +_loop: + _readState.afterAdvanceFailure(iprot); + if (_readState.atStop()) { + goto _end; + } + if (iprot->kUsesFieldNames()) { + _readState.template fillFieldTraitsFromName>(); + } + + switch (_readState.fieldId) { + case 1: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_STRUCT))) { + goto _readField_update_edge_request; + } else { + goto _skip; + } + } + case 2: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I64))) { + goto _readField_term; + } else { + goto _skip; + } + } + case 3: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I64))) { + goto _readField_edge_version; + } else { + goto _skip; + } + } + case 4: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_I32))) { + goto _readField_space_id; + } else { + goto _skip; + } + } + case 5: + { + if (LIKELY(_readState.isCompatibleWithType(iprot, apache::thrift::protocol::T_LIST))) { + goto _readField_parts; + } else { + goto _skip; + } + } + default: + { +_skip: + _readState.skip(iprot); + _readState.readFieldEnd(iprot); + _readState.readFieldBeginNoInline(iprot); + goto _loop; + } + } +} + +template +uint32_t ChainUpdateEdgeRequest::serializedSize(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ChainUpdateEdgeRequest"); + xfer += prot_->serializedFieldSize("update_edge_request", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::UpdateEdgeRequest>::serializedSize(*prot_, this->update_edge_request); + xfer += prot_->serializedFieldSize("term", apache::thrift::protocol::T_I64, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::serializedSize(*prot_, this->term); + if (this->edge_version_ref().has_value()) { + xfer += prot_->serializedFieldSize("edge_version", apache::thrift::protocol::T_I64, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::serializedSize(*prot_, this->edge_version); + } + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("parts", apache::thrift::protocol::T_LIST, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::integral>, ::std::vector< ::nebula::cpp2::PartitionID>>::serializedSize(*prot_, this->parts); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ChainUpdateEdgeRequest::serializedSizeZC(Protocol_ const* prot_) const { + uint32_t xfer = 0; + xfer += prot_->serializedStructSize("ChainUpdateEdgeRequest"); + xfer += prot_->serializedFieldSize("update_edge_request", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::UpdateEdgeRequest>::serializedSize(*prot_, this->update_edge_request); + xfer += prot_->serializedFieldSize("term", apache::thrift::protocol::T_I64, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::serializedSize(*prot_, this->term); + if (this->edge_version_ref().has_value()) { + xfer += prot_->serializedFieldSize("edge_version", apache::thrift::protocol::T_I64, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::serializedSize(*prot_, this->edge_version); + } + xfer += prot_->serializedFieldSize("space_id", apache::thrift::protocol::T_I32, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::serializedSize(*prot_, this->space_id); + xfer += prot_->serializedFieldSize("parts", apache::thrift::protocol::T_LIST, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::integral>, ::std::vector< ::nebula::cpp2::PartitionID>>::serializedSize(*prot_, this->parts); + xfer += prot_->serializedSizeStop(); + return xfer; +} + +template +uint32_t ChainUpdateEdgeRequest::write(Protocol_* prot_) const { + uint32_t xfer = 0; + xfer += prot_->writeStructBegin("ChainUpdateEdgeRequest"); + xfer += prot_->writeFieldBegin("update_edge_request", apache::thrift::protocol::T_STRUCT, 1); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::structure, ::nebula::storage::cpp2::UpdateEdgeRequest>::write(*prot_, this->update_edge_request); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("term", apache::thrift::protocol::T_I64, 2); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::write(*prot_, this->term); + xfer += prot_->writeFieldEnd(); + if (this->edge_version_ref().has_value()) { + xfer += prot_->writeFieldBegin("edge_version", apache::thrift::protocol::T_I64, 3); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, int64_t>::write(*prot_, this->edge_version); + xfer += prot_->writeFieldEnd(); + } + xfer += prot_->writeFieldBegin("space_id", apache::thrift::protocol::T_I32, 4); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::integral, ::nebula::cpp2::GraphSpaceID>::write(*prot_, this->space_id); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldBegin("parts", apache::thrift::protocol::T_LIST, 5); + xfer += ::apache::thrift::detail::pm::protocol_methods< ::apache::thrift::type_class::list<::apache::thrift::type_class::integral>, ::std::vector< ::nebula::cpp2::PartitionID>>::write(*prot_, this->parts); + xfer += prot_->writeFieldEnd(); + xfer += prot_->writeFieldStop(); + xfer += prot_->writeStructEnd(); + return xfer; +} + +extern template void ChainUpdateEdgeRequest::readNoXfer<>(apache::thrift::BinaryProtocolReader*); +extern template uint32_t ChainUpdateEdgeRequest::write<>(apache::thrift::BinaryProtocolWriter*) const; +extern template uint32_t ChainUpdateEdgeRequest::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template uint32_t ChainUpdateEdgeRequest::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const; +extern template void ChainUpdateEdgeRequest::readNoXfer<>(apache::thrift::CompactProtocolReader*); +extern template uint32_t ChainUpdateEdgeRequest::write<>(apache::thrift::CompactProtocolWriter*) const; +extern template uint32_t ChainUpdateEdgeRequest::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const; +extern template uint32_t ChainUpdateEdgeRequest::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const; + +}}} // nebula::storage::cpp2 diff --git a/src/interface/gen-cpp2/storage_types_custom_protocol.h b/src/interface/gen-cpp2/storage_types_custom_protocol.h new file mode 100644 index 00000000..e2def20b --- /dev/null +++ b/src/interface/gen-cpp2/storage_types_custom_protocol.h @@ -0,0 +1,20 @@ +/** + * Autogenerated by Thrift for storage.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#pragma once + + +/** + * This header file includes the tcc files of the corresponding header file + * and the header files of its dependent types. Include this header file + * only when you need to use custom protocols (e.g. DebugProtocol, + * VirtualProtocol) to read/write thrift structs. + */ + +#include "storage_types.tcc" + +#include "common_types_custom_protocol.h" +#include "meta_types_custom_protocol.h" diff --git a/src/interface/gen-cpp2/storage_visit_by_thrift_field_metadata.h b/src/interface/gen-cpp2/storage_visit_by_thrift_field_metadata.h new file mode 100644 index 00000000..dc71a52c --- /dev/null +++ b/src/interface/gen-cpp2/storage_visit_by_thrift_field_metadata.h @@ -0,0 +1,1224 @@ +/** + * Autogenerated by Thrift for storage.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#pragma once + +#include +#include "storage_metadata.h" + +namespace apache { +namespace thrift { +namespace detail { + +template <> +struct VisitByThriftId<::nebula::storage::cpp2::RequestCommon> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).session_id_ref()); + case 2: + return f(1, static_cast(t).plan_id_ref()); + case 3: + return f(2, static_cast(t).profile_detail_ref()); + default: + throwInvalidThriftId(id, "::nebula::storage::cpp2::RequestCommon"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::storage::cpp2::PartitionResult> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).code_ref()); + case 2: + return f(1, static_cast(t).part_id_ref()); + case 3: + return f(2, static_cast(t).leader_ref()); + default: + throwInvalidThriftId(id, "::nebula::storage::cpp2::PartitionResult"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::storage::cpp2::ResponseCommon> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).failed_parts_ref()); + case 2: + return f(1, static_cast(t).latency_in_us_ref()); + case 3: + return f(2, static_cast(t).latency_detail_us_ref()); + default: + throwInvalidThriftId(id, "::nebula::storage::cpp2::ResponseCommon"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::storage::cpp2::StatProp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).alias_ref()); + case 2: + return f(1, static_cast(t).prop_ref()); + case 3: + return f(2, static_cast(t).stat_ref()); + default: + throwInvalidThriftId(id, "::nebula::storage::cpp2::StatProp"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::storage::cpp2::Expr> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).alias_ref()); + case 2: + return f(1, static_cast(t).expr_ref()); + default: + throwInvalidThriftId(id, "::nebula::storage::cpp2::Expr"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::storage::cpp2::EdgeProp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).type_ref()); + case 2: + return f(1, static_cast(t).props_ref()); + default: + throwInvalidThriftId(id, "::nebula::storage::cpp2::EdgeProp"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::storage::cpp2::VertexProp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).tag_ref()); + case 2: + return f(1, static_cast(t).props_ref()); + default: + throwInvalidThriftId(id, "::nebula::storage::cpp2::VertexProp"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::storage::cpp2::OrderBy> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).prop_ref()); + case 2: + return f(1, static_cast(t).direction_ref()); + default: + throwInvalidThriftId(id, "::nebula::storage::cpp2::OrderBy"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::storage::cpp2::TraverseSpec> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).edge_types_ref()); + case 2: + return f(1, static_cast(t).edge_direction_ref()); + case 3: + return f(2, static_cast(t).dedup_ref()); + case 4: + return f(3, static_cast(t).stat_props_ref()); + case 5: + return f(4, static_cast(t).vertex_props_ref()); + case 6: + return f(5, static_cast(t).edge_props_ref()); + case 7: + return f(6, static_cast(t).expressions_ref()); + case 8: + return f(7, static_cast(t).order_by_ref()); + case 9: + return f(8, static_cast(t).random_ref()); + case 10: + return f(9, static_cast(t).limit_ref()); + case 11: + return f(10, static_cast(t).filter_ref()); + default: + throwInvalidThriftId(id, "::nebula::storage::cpp2::TraverseSpec"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::storage::cpp2::GetNeighborsRequest> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).space_id_ref()); + case 2: + return f(1, static_cast(t).column_names_ref()); + case 3: + return f(2, static_cast(t).parts_ref()); + case 4: + return f(3, static_cast(t).traverse_spec_ref()); + case 5: + return f(4, static_cast(t).common_ref()); + default: + throwInvalidThriftId(id, "::nebula::storage::cpp2::GetNeighborsRequest"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::storage::cpp2::GetNeighborsResponse> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).result_ref()); + case 2: + return f(1, static_cast(t).vertices_ref()); + default: + throwInvalidThriftId(id, "::nebula::storage::cpp2::GetNeighborsResponse"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::storage::cpp2::ExecResponse> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).result_ref()); + default: + throwInvalidThriftId(id, "::nebula::storage::cpp2::ExecResponse"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::storage::cpp2::GetPropRequest> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).space_id_ref()); + case 2: + return f(1, static_cast(t).parts_ref()); + case 3: + return f(2, static_cast(t).vertex_props_ref()); + case 4: + return f(3, static_cast(t).edge_props_ref()); + case 5: + return f(4, static_cast(t).expressions_ref()); + case 6: + return f(5, static_cast(t).dedup_ref()); + case 7: + return f(6, static_cast(t).order_by_ref()); + case 8: + return f(7, static_cast(t).limit_ref()); + case 9: + return f(8, static_cast(t).filter_ref()); + case 10: + return f(9, static_cast(t).common_ref()); + default: + throwInvalidThriftId(id, "::nebula::storage::cpp2::GetPropRequest"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::storage::cpp2::GetPropResponse> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).result_ref()); + case 2: + return f(1, static_cast(t).props_ref()); + default: + throwInvalidThriftId(id, "::nebula::storage::cpp2::GetPropResponse"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::storage::cpp2::NewTag> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).tag_id_ref()); + case 2: + return f(1, static_cast(t).props_ref()); + default: + throwInvalidThriftId(id, "::nebula::storage::cpp2::NewTag"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::storage::cpp2::NewVertex> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).id_ref()); + case 2: + return f(1, static_cast(t).tags_ref()); + default: + throwInvalidThriftId(id, "::nebula::storage::cpp2::NewVertex"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::storage::cpp2::EdgeKey> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).src_ref()); + case 2: + return f(1, static_cast(t).edge_type_ref()); + case 3: + return f(2, static_cast(t).ranking_ref()); + case 4: + return f(3, static_cast(t).dst_ref()); + default: + throwInvalidThriftId(id, "::nebula::storage::cpp2::EdgeKey"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::storage::cpp2::NewEdge> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).key_ref()); + case 2: + return f(1, static_cast(t).props_ref()); + default: + throwInvalidThriftId(id, "::nebula::storage::cpp2::NewEdge"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::storage::cpp2::AddVerticesRequest> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).space_id_ref()); + case 2: + return f(1, static_cast(t).parts_ref()); + case 3: + return f(2, static_cast(t).prop_names_ref()); + case 4: + return f(3, static_cast(t).if_not_exists_ref()); + case 5: + return f(4, static_cast(t).common_ref()); + default: + throwInvalidThriftId(id, "::nebula::storage::cpp2::AddVerticesRequest"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::storage::cpp2::AddEdgesRequest> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).space_id_ref()); + case 2: + return f(1, static_cast(t).parts_ref()); + case 3: + return f(2, static_cast(t).prop_names_ref()); + case 4: + return f(3, static_cast(t).if_not_exists_ref()); + case 5: + return f(4, static_cast(t).common_ref()); + default: + throwInvalidThriftId(id, "::nebula::storage::cpp2::AddEdgesRequest"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::storage::cpp2::DeleteVerticesRequest> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).space_id_ref()); + case 2: + return f(1, static_cast(t).parts_ref()); + case 3: + return f(2, static_cast(t).common_ref()); + default: + throwInvalidThriftId(id, "::nebula::storage::cpp2::DeleteVerticesRequest"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::storage::cpp2::DeleteEdgesRequest> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).space_id_ref()); + case 2: + return f(1, static_cast(t).parts_ref()); + case 3: + return f(2, static_cast(t).common_ref()); + default: + throwInvalidThriftId(id, "::nebula::storage::cpp2::DeleteEdgesRequest"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::storage::cpp2::DelTags> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).id_ref()); + case 2: + return f(1, static_cast(t).tags_ref()); + default: + throwInvalidThriftId(id, "::nebula::storage::cpp2::DelTags"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::storage::cpp2::DeleteTagsRequest> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).space_id_ref()); + case 2: + return f(1, static_cast(t).parts_ref()); + case 3: + return f(2, static_cast(t).common_ref()); + default: + throwInvalidThriftId(id, "::nebula::storage::cpp2::DeleteTagsRequest"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::storage::cpp2::UpdateResponse> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).result_ref()); + case 2: + return f(1, static_cast(t).props_ref()); + default: + throwInvalidThriftId(id, "::nebula::storage::cpp2::UpdateResponse"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::storage::cpp2::UpdatedProp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).name_ref()); + case 2: + return f(1, static_cast(t).value_ref()); + default: + throwInvalidThriftId(id, "::nebula::storage::cpp2::UpdatedProp"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::storage::cpp2::UpdateVertexRequest> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).space_id_ref()); + case 2: + return f(1, static_cast(t).part_id_ref()); + case 3: + return f(2, static_cast(t).vertex_id_ref()); + case 4: + return f(3, static_cast(t).tag_id_ref()); + case 5: + return f(4, static_cast(t).updated_props_ref()); + case 6: + return f(5, static_cast(t).insertable_ref()); + case 7: + return f(6, static_cast(t).return_props_ref()); + case 8: + return f(7, static_cast(t).condition_ref()); + case 9: + return f(8, static_cast(t).common_ref()); + default: + throwInvalidThriftId(id, "::nebula::storage::cpp2::UpdateVertexRequest"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::storage::cpp2::UpdateEdgeRequest> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).space_id_ref()); + case 2: + return f(1, static_cast(t).part_id_ref()); + case 3: + return f(2, static_cast(t).edge_key_ref()); + case 4: + return f(3, static_cast(t).updated_props_ref()); + case 5: + return f(4, static_cast(t).insertable_ref()); + case 6: + return f(5, static_cast(t).return_props_ref()); + case 7: + return f(6, static_cast(t).condition_ref()); + case 8: + return f(7, static_cast(t).common_ref()); + default: + throwInvalidThriftId(id, "::nebula::storage::cpp2::UpdateEdgeRequest"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::storage::cpp2::GetUUIDReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).space_id_ref()); + case 2: + return f(1, static_cast(t).part_id_ref()); + case 3: + return f(2, static_cast(t).name_ref()); + case 4: + return f(3, static_cast(t).common_ref()); + default: + throwInvalidThriftId(id, "::nebula::storage::cpp2::GetUUIDReq"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::storage::cpp2::GetUUIDResp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).result_ref()); + case 2: + return f(1, static_cast(t).id_ref()); + default: + throwInvalidThriftId(id, "::nebula::storage::cpp2::GetUUIDResp"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::storage::cpp2::LookupIndexResp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).result_ref()); + case 2: + return f(1, static_cast(t).data_ref()); + default: + throwInvalidThriftId(id, "::nebula::storage::cpp2::LookupIndexResp"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::storage::cpp2::IndexColumnHint> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).column_name_ref()); + case 2: + return f(1, static_cast(t).scan_type_ref()); + case 3: + return f(2, static_cast(t).begin_value_ref()); + case 4: + return f(3, static_cast(t).end_value_ref()); + default: + throwInvalidThriftId(id, "::nebula::storage::cpp2::IndexColumnHint"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::storage::cpp2::IndexQueryContext> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).index_id_ref()); + case 2: + return f(1, static_cast(t).filter_ref()); + case 3: + return f(2, static_cast(t).column_hints_ref()); + default: + throwInvalidThriftId(id, "::nebula::storage::cpp2::IndexQueryContext"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::storage::cpp2::IndexSpec> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).contexts_ref()); + case 2: + return f(1, static_cast(t).schema_id_ref()); + default: + throwInvalidThriftId(id, "::nebula::storage::cpp2::IndexSpec"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::storage::cpp2::LookupIndexRequest> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).space_id_ref()); + case 2: + return f(1, static_cast(t).parts_ref()); + case 3: + return f(2, static_cast(t).indices_ref()); + case 4: + return f(3, static_cast(t).return_columns_ref()); + case 5: + return f(4, static_cast(t).common_ref()); + case 6: + return f(5, static_cast(t).limit_ref()); + default: + throwInvalidThriftId(id, "::nebula::storage::cpp2::LookupIndexRequest"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::storage::cpp2::LookupAndTraverseRequest> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).space_id_ref()); + case 2: + return f(1, static_cast(t).parts_ref()); + case 3: + return f(2, static_cast(t).indices_ref()); + case 4: + return f(3, static_cast(t).traverse_spec_ref()); + case 5: + return f(4, static_cast(t).common_ref()); + default: + throwInvalidThriftId(id, "::nebula::storage::cpp2::LookupAndTraverseRequest"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::storage::cpp2::ScanVertexRequest> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).space_id_ref()); + case 2: + return f(1, static_cast(t).part_id_ref()); + case 3: + return f(2, static_cast(t).cursor_ref()); + case 4: + return f(3, static_cast(t).return_columns_ref()); + case 5: + return f(4, static_cast(t).limit_ref()); + case 6: + return f(5, static_cast(t).start_time_ref()); + case 7: + return f(6, static_cast(t).end_time_ref()); + case 8: + return f(7, static_cast(t).filter_ref()); + case 9: + return f(8, static_cast(t).only_latest_version_ref()); + case 10: + return f(9, static_cast(t).enable_read_from_follower_ref()); + case 11: + return f(10, static_cast(t).common_ref()); + default: + throwInvalidThriftId(id, "::nebula::storage::cpp2::ScanVertexRequest"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::storage::cpp2::ScanVertexResponse> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).result_ref()); + case 2: + return f(1, static_cast(t).vertex_data_ref()); + case 3: + return f(2, static_cast(t).has_next_ref()); + case 4: + return f(3, static_cast(t).next_cursor_ref()); + default: + throwInvalidThriftId(id, "::nebula::storage::cpp2::ScanVertexResponse"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::storage::cpp2::ScanEdgeRequest> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).space_id_ref()); + case 2: + return f(1, static_cast(t).part_id_ref()); + case 3: + return f(2, static_cast(t).cursor_ref()); + case 4: + return f(3, static_cast(t).return_columns_ref()); + case 5: + return f(4, static_cast(t).limit_ref()); + case 6: + return f(5, static_cast(t).start_time_ref()); + case 7: + return f(6, static_cast(t).end_time_ref()); + case 8: + return f(7, static_cast(t).filter_ref()); + case 9: + return f(8, static_cast(t).only_latest_version_ref()); + case 10: + return f(9, static_cast(t).enable_read_from_follower_ref()); + case 11: + return f(10, static_cast(t).common_ref()); + default: + throwInvalidThriftId(id, "::nebula::storage::cpp2::ScanEdgeRequest"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::storage::cpp2::ScanEdgeResponse> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).result_ref()); + case 2: + return f(1, static_cast(t).edge_data_ref()); + case 3: + return f(2, static_cast(t).has_next_ref()); + case 4: + return f(3, static_cast(t).next_cursor_ref()); + default: + throwInvalidThriftId(id, "::nebula::storage::cpp2::ScanEdgeResponse"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::storage::cpp2::TaskPara> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).space_id_ref()); + case 2: + return f(1, static_cast(t).parts_ref()); + case 3: + return f(2, static_cast(t).task_specfic_paras_ref()); + default: + throwInvalidThriftId(id, "::nebula::storage::cpp2::TaskPara"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::storage::cpp2::AddAdminTaskRequest> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).cmd_ref()); + case 2: + return f(1, static_cast(t).job_id_ref()); + case 3: + return f(2, static_cast(t).task_id_ref()); + case 4: + return f(3, static_cast(t).para_ref()); + case 5: + return f(4, static_cast(t).concurrency_ref()); + default: + throwInvalidThriftId(id, "::nebula::storage::cpp2::AddAdminTaskRequest"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::storage::cpp2::StopAdminTaskRequest> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).job_id_ref()); + case 2: + return f(1, static_cast(t).task_id_ref()); + default: + throwInvalidThriftId(id, "::nebula::storage::cpp2::StopAdminTaskRequest"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::storage::cpp2::AdminExecResp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).result_ref()); + case 2: + return f(1, static_cast(t).stats_ref()); + default: + throwInvalidThriftId(id, "::nebula::storage::cpp2::AdminExecResp"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::storage::cpp2::TransLeaderReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).space_id_ref()); + case 2: + return f(1, static_cast(t).part_id_ref()); + case 3: + return f(2, static_cast(t).new_leader_ref()); + default: + throwInvalidThriftId(id, "::nebula::storage::cpp2::TransLeaderReq"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::storage::cpp2::AddPartReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).space_id_ref()); + case 2: + return f(1, static_cast(t).part_id_ref()); + case 3: + return f(2, static_cast(t).as_learner_ref()); + case 4: + return f(3, static_cast(t).peers_ref()); + default: + throwInvalidThriftId(id, "::nebula::storage::cpp2::AddPartReq"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::storage::cpp2::AddLearnerReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).space_id_ref()); + case 2: + return f(1, static_cast(t).part_id_ref()); + case 3: + return f(2, static_cast(t).learner_ref()); + default: + throwInvalidThriftId(id, "::nebula::storage::cpp2::AddLearnerReq"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::storage::cpp2::RemovePartReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).space_id_ref()); + case 2: + return f(1, static_cast(t).part_id_ref()); + default: + throwInvalidThriftId(id, "::nebula::storage::cpp2::RemovePartReq"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::storage::cpp2::MemberChangeReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).space_id_ref()); + case 2: + return f(1, static_cast(t).part_id_ref()); + case 3: + return f(2, static_cast(t).peer_ref()); + case 4: + return f(3, static_cast(t).add_ref()); + default: + throwInvalidThriftId(id, "::nebula::storage::cpp2::MemberChangeReq"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::storage::cpp2::CatchUpDataReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).space_id_ref()); + case 2: + return f(1, static_cast(t).part_id_ref()); + case 3: + return f(2, static_cast(t).target_ref()); + default: + throwInvalidThriftId(id, "::nebula::storage::cpp2::CatchUpDataReq"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::storage::cpp2::GetLeaderReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + default: + throwInvalidThriftId(id, "::nebula::storage::cpp2::GetLeaderReq"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::storage::cpp2::CreateCPRequest> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).space_id_ref()); + case 2: + return f(1, static_cast(t).name_ref()); + default: + throwInvalidThriftId(id, "::nebula::storage::cpp2::CreateCPRequest"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::storage::cpp2::DropCPRequest> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).space_id_ref()); + case 2: + return f(1, static_cast(t).name_ref()); + default: + throwInvalidThriftId(id, "::nebula::storage::cpp2::DropCPRequest"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::storage::cpp2::BlockingSignRequest> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).space_id_ref()); + case 2: + return f(1, static_cast(t).sign_ref()); + default: + throwInvalidThriftId(id, "::nebula::storage::cpp2::BlockingSignRequest"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::storage::cpp2::GetLeaderPartsResp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).result_ref()); + case 2: + return f(1, static_cast(t).leader_parts_ref()); + default: + throwInvalidThriftId(id, "::nebula::storage::cpp2::GetLeaderPartsResp"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::storage::cpp2::CheckPeersReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).space_id_ref()); + case 2: + return f(1, static_cast(t).part_id_ref()); + case 3: + return f(2, static_cast(t).peers_ref()); + default: + throwInvalidThriftId(id, "::nebula::storage::cpp2::CheckPeersReq"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::storage::cpp2::RebuildIndexRequest> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).space_id_ref()); + case 2: + return f(1, static_cast(t).parts_ref()); + case 3: + return f(2, static_cast(t).index_id_ref()); + default: + throwInvalidThriftId(id, "::nebula::storage::cpp2::RebuildIndexRequest"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::storage::cpp2::CreateCPResp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).result_ref()); + case 2: + return f(1, static_cast(t).info_ref()); + default: + throwInvalidThriftId(id, "::nebula::storage::cpp2::CreateCPResp"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::storage::cpp2::ListClusterInfoResp> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).result_ref()); + case 2: + return f(1, static_cast(t).dir_ref()); + default: + throwInvalidThriftId(id, "::nebula::storage::cpp2::ListClusterInfoResp"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::storage::cpp2::ListClusterInfoReq> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + default: + throwInvalidThriftId(id, "::nebula::storage::cpp2::ListClusterInfoReq"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::storage::cpp2::KVGetRequest> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).space_id_ref()); + case 2: + return f(1, static_cast(t).parts_ref()); + case 3: + return f(2, static_cast(t).return_partly_ref()); + default: + throwInvalidThriftId(id, "::nebula::storage::cpp2::KVGetRequest"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::storage::cpp2::KVGetResponse> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).result_ref()); + case 2: + return f(1, static_cast(t).key_values_ref()); + default: + throwInvalidThriftId(id, "::nebula::storage::cpp2::KVGetResponse"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::storage::cpp2::KVPutRequest> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).space_id_ref()); + case 2: + return f(1, static_cast(t).parts_ref()); + default: + throwInvalidThriftId(id, "::nebula::storage::cpp2::KVPutRequest"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::storage::cpp2::KVRemoveRequest> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).space_id_ref()); + case 2: + return f(1, static_cast(t).parts_ref()); + default: + throwInvalidThriftId(id, "::nebula::storage::cpp2::KVRemoveRequest"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::storage::cpp2::InternalTxnRequest> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).txn_id_ref()); + case 2: + return f(1, static_cast(t).term_of_parts_ref()); + case 3: + return f(2, static_cast(t).add_edge_req_ref()); + case 4: + return f(3, static_cast(t).upd_edge_req_ref()); + case 5: + return f(4, static_cast(t).edge_ver_ref()); + default: + throwInvalidThriftId(id, "::nebula::storage::cpp2::InternalTxnRequest"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::storage::cpp2::ChainAddEdgesRequest> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).space_id_ref()); + case 2: + return f(1, static_cast(t).parts_ref()); + case 3: + return f(2, static_cast(t).prop_names_ref()); + case 4: + return f(3, static_cast(t).if_not_exists_ref()); + case 5: + return f(4, static_cast(t).term_ref()); + case 6: + return f(5, static_cast(t).edge_version_ref()); + default: + throwInvalidThriftId(id, "::nebula::storage::cpp2::ChainAddEdgesRequest"); + } + } +}; + +template <> +struct VisitByThriftId<::nebula::storage::cpp2::ChainUpdateEdgeRequest> { + template + void operator()(FOLLY_MAYBE_UNUSED F&& f, size_t id, FOLLY_MAYBE_UNUSED T&& t) const { + switch (id) { + case 1: + return f(0, static_cast(t).update_edge_request_ref()); + case 2: + return f(1, static_cast(t).term_ref()); + case 3: + return f(2, static_cast(t).edge_version_ref()); + case 4: + return f(3, static_cast(t).space_id_ref()); + case 5: + return f(4, static_cast(t).parts_ref()); + default: + throwInvalidThriftId(id, "::nebula::storage::cpp2::ChainUpdateEdgeRequest"); + } + } +}; +} // namespace detail +} // namespace thrift +} // namespace apache diff --git a/src/interface/gen-cpp2/storage_visit_union.h b/src/interface/gen-cpp2/storage_visit_union.h new file mode 100644 index 00000000..1b34547b --- /dev/null +++ b/src/interface/gen-cpp2/storage_visit_union.h @@ -0,0 +1,18 @@ +/** + * Autogenerated by Thrift for storage.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#pragma once + +#include "storage_metadata.h" +#include + +namespace apache { +namespace thrift { +namespace detail { + +} // namespace detail +} // namespace thrift +} // namespace apache diff --git a/src/interface/gen-cpp2/storage_visitation.h b/src/interface/gen-cpp2/storage_visitation.h new file mode 100644 index 00000000..a66d00cd --- /dev/null +++ b/src/interface/gen-cpp2/storage_visitation.h @@ -0,0 +1,11 @@ +/** + * Autogenerated by Thrift for storage.thrift + * + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * @generated + */ +#pragma once +#include "common_visitation.h" +#include "meta_visitation.h" +#include "storage_for_each_field.h" +#include "storage_visit_union.h" diff --git a/src/time/TimeConversion.cpp b/src/time/TimeConversion.cpp new file mode 100644 index 00000000..22197eb6 --- /dev/null +++ b/src/time/TimeConversion.cpp @@ -0,0 +1,97 @@ +/* Copyright (c) 2021 vesoft inc. All rights reserved. + * + * This source code is licensed under Apache 2.0 License, + * attached with Common Clause Condition 1.0, found in the LICENSES directory. + */ + +#include "common/time/TimeConversion.h" + +namespace nebula { +namespace time { + +const DateTime TimeConversion::kEpoch(1970, 1, 1, 0, 0, 0, 0); + +/*static*/ int64_t TimeConversion::dateTimeDiffSeconds(const DateTime &dateTime0, + const DateTime &dateTime1) { + // check the negative divide result, it's used in the negative year number + // computing. + static_assert(-1 / 2 == 0, ""); + // Year Base Verification + static_assert(0 % 100 == 0, ""); + + // Compute intervening leap days correctly even if year is negative. + // take care to avoid integer overflow here. + int a4 = shr(dateTime0.year, 2) + shr(0, 2) - !(dateTime0.year & 3); + int b4 = shr(dateTime1.year, 2) + shr(0, 2) - !(dateTime1.year & 3); + int a100 = (a4 + (a4 < 0)) / 25 - (a4 < 0); + int b100 = (b4 + (b4 < 0)) / 25 - (b4 < 0); + int a400 = shr(a100, 2); + int b400 = shr(b100, 2); + int intervening_leap_days = (a4 - b4) - (a100 - b100) + (a400 - b400); + + /* Compute the desired time without overflowing. */ + int64_t years = dateTime0.year - dateTime1.year; + int64_t days = 365 * years + + (isLeapYear(dateTime0.year) ? kLeapDaysSoFar[dateTime0.month - 1] + : kDaysSoFar[dateTime0.month - 1]) - + (isLeapYear(dateTime1.year) ? kLeapDaysSoFar[dateTime1.month - 1] + : kDaysSoFar[dateTime1.month - 1]) + + dateTime0.day - dateTime1.day + intervening_leap_days; + int64_t hours = 24 * days + dateTime0.hour - dateTime1.hour; + int64_t minutes = 60 * hours + dateTime0.minute - dateTime1.minute; + int64_t seconds = 60 * minutes + dateTime0.sec - dateTime1.sec; + return seconds; +} + +/*static*/ DateTime TimeConversion::unixSecondsToDateTime(int64_t seconds) { + DateTime dt; + int64_t days, rem, y; + const int64_t *ip; + + days = seconds / kSecondsOfDay; + rem = seconds % kSecondsOfDay; + while (rem < 0) { + rem += kSecondsOfDay; + --days; + } + while (rem >= kSecondsOfDay) { + rem -= kSecondsOfDay; + ++days; + } + dt.hour = rem / kSecondsOfHour; + rem %= kSecondsOfHour; + dt.minute = rem / kSecondsOfMinute; + dt.sec = rem % kSecondsOfMinute; + y = 1970; + +#define DIV(a, b) ((a) / (b) - ((a) % (b) < 0)) +#define LEAPS_THRU_END_OF(y) (DIV(y, 4) - DIV(y, 100) + DIV(y, 400)) + + while (days < 0 || days >= (isLeapYear(y) ? kDayOfLeapYear : kDayOfCommonYear)) { + /* Guess a corrected year, assuming 365 days per year. */ + int64_t yg = y + days / kDayOfCommonYear - (days % kDayOfCommonYear < 0); + + /* Adjust DAYS and Y to match the guessed year. */ + days -= + ((yg - y) * kDayOfCommonYear + LEAPS_THRU_END_OF(yg - 1) - LEAPS_THRU_END_OF(y - 1)); + y = yg; + } + dt.year = y; + if (dt.year != y) { + // overflow + } + ip = (isLeapYear(y) ? kLeapDaysSoFar : kDaysSoFar); + for (y = 11; days < ip[y]; --y) { + continue; + } + days -= ip[y]; + dt.month = y + 1; + dt.day = days + 1; + return dt; +} + +#undef DIV +#undef LEAPS_THRU_END_OF + +} // namespace time +} // namespace nebula From f9ee81e50e9d0e324f17a8f8f496463fd5f25c1c Mon Sep 17 00:00:00 2001 From: Shylock Hg <33566796+Shylock-Hg@users.noreply.github.com> Date: Tue, 12 Oct 2021 17:16:13 +0800 Subject: [PATCH 02/14] Don't lint auto generated files. --- .github/workflows/pull_request.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/pull_request.yml b/.github/workflows/pull_request.yml index 44c5b26e..a6c73fa9 100644 --- a/.github/workflows/pull_request.yml +++ b/.github/workflows/pull_request.yml @@ -26,7 +26,7 @@ jobs: - name: Cpplint run: | ln -snf $PWD/.linters/cpp/hooks/pre-commit.sh $PWD/.linters/cpp/pre-commit.sh - .linters/cpp/pre-commit.sh $(git --no-pager diff --diff-filter=d --name-only HEAD^ HEAD) + .linters/cpp/pre-commit.sh build: name: build From df7492fdaaf6d639ce394dfe13f8e5c55c831885 Mon Sep 17 00:00:00 2001 From: Shylock Hg <33566796+Shylock-Hg@users.noreply.github.com> Date: Tue, 12 Oct 2021 17:24:35 +0800 Subject: [PATCH 03/14] Add third-party --- third-party/cxx-compiler-abi-version.sh | 27 ++++++ third-party/install-cmake.sh | 71 +++++++++++++++ third-party/install-gcc.sh | 116 ++++++++++++++++++++++++ third-party/install-third-party.sh | 104 +++++++++++++++++++++ 4 files changed, 318 insertions(+) create mode 100755 third-party/cxx-compiler-abi-version.sh create mode 100755 third-party/install-cmake.sh create mode 100755 third-party/install-gcc.sh create mode 100755 third-party/install-third-party.sh diff --git a/third-party/cxx-compiler-abi-version.sh b/third-party/cxx-compiler-abi-version.sh new file mode 100755 index 00000000..15064385 --- /dev/null +++ b/third-party/cxx-compiler-abi-version.sh @@ -0,0 +1,27 @@ +#! /usr/bin/env bash + +# Copyright (c) 2019 vesoft inc. All rights reserved. +# +# This source code is licensed under Apache 2.0 License, +# attached with Common Clause Condition 1.0, found in the LICENSES directory. + +set -e +abi="unknown" +cxx_cmd=${CXX:-g++} +link_flags="-std=c++14 -static-libstdc++ -static-libgcc" +[[ $disable_cxx11_abi -ne 0 ]] && extra_flags="$extra_flags -D_GLIBCXX_USE_CXX11_ABI=0" +tmpdir=$(mktemp -q -d /tmp/nebula-compiler-test.XXXX 2>/dev/null) +object=$tmpdir/a.out.o + +$cxx_cmd $link_flags $extra_flags -g -x c++ - -c -o $object > /dev/null < +void foobar(std::string) { +} +EOF + +string=$(nm -C $object | sed -nr 's/.*foobar.*(std.*string).*/\1/p') + +[[ $string = 'std::__cxx11::basic_string' ]] && abi=11 +[[ $string = 'std::string' ]] && abi=98 + +echo $abi diff --git a/third-party/install-cmake.sh b/third-party/install-cmake.sh new file mode 100755 index 00000000..f9699751 --- /dev/null +++ b/third-party/install-cmake.sh @@ -0,0 +1,71 @@ +#! /usr/bin/env bash + +# Copyright (c) 2019 vesoft inc. All rights reserved. +# +# This source code is licensed under Apache 2.0 License, +# attached with Common Clause Condition 1.0, found in the LICENSES directory. + +# Usage: build-cmake.sh [prefix] + +# Always use bash +shell=$(basename $(readlink /proc/$$/exe)) +if [ ! x$shell = x"bash" ] +then + bash $0 $@ + exit $? +fi + +archive=cmake-3.15.5-Linux-x86_64.sh +url=https://cmake.org/files/v3.15/$archive +prefix=`pwd`/cmake-3.15.5 + +if [[ -n $1 ]] +then + prefix=$1 +fi + +if [[ -f $archive ]] +then + checksum=$(md5sum $archive | cut -d ' ' -f 1) +fi + +if [[ ! $checksum = 35d56e9c27b4fd2819a11c29320c655a ]] +then + hash wget &> /dev/null && download_cmd="wget -c" + hash axel &> /dev/null && download_cmd="axel -a -n 8" + if [[ -z $download_cmd ]] + then + echo "'wget' not found for downloading" 1>&2; + exit 1; + fi + + echo "Downloading with $download_cmd..." + if ! bash -c "$download_cmd $url" + then + echo "Download failed." + exit 1 + fi +fi + +set -e +mkdir -p $prefix +bash $archive --prefix=$prefix &> /dev/null < $prefix/bin/enable-cmake.sh < $prefix/bin/disable-cmake.sh </dev/null || { + echo "'wget' not fould, please install it first" 1>&2 + exit 1 +} + +download_cmd="wget -c" +wget --help | grep -q '\--show-progress' && \ + download_cmd="$download_cmd -q --show-progress" || \ + download_cmd="$download_cmd --progress=bar:force:noscroll" + +# Guess the root distro +[[ "$this_distro" = CentOS ]] && selected_distro=CentOS +[[ "$this_distro" = RedHat ]] && selected_distro=CentOS +[[ "$this_distro" = Fedora ]] && selected_distro=CentOS +[[ "$this_distro" = Debian ]] && selected_distro=Debian +[[ "$this_distro" = Ubuntu ]] && selected_distro=Debian +[[ "$this_distro" = LinuxMint ]] && selected_distro=Debian + +# backoff distro +[[ -n $this_distro ]] || selected_distro=Debian + +function version_cmp { + mapfile -t left < <( echo $1 | tr . '\n' ) + mapfile -t right < <( echo $2 | tr . '\n') + local i + for i in ${!left[@]} + do + local lv=${left[$i]} + local rv=${right[$i]} + [[ -z $rv ]] && { echo $lv; return; } + [[ $lv -ne $rv ]] && { echo $((lv - rv)); return; } + done + ((i++)) + rv=${right[$i]} + [[ ${#right[@]} -gt ${#left[@]} ]] && { echo $((0-rv)); return; } +} + +# Find the maximum version not greater than the system one +function select_libc { + local this_version=$1 + shift 1 + local candidates="$@" + for v in $candidates + do + if [[ $(version_cmp $v $this_version) -le 0 ]] + then + echo $v + break + fi + done +} + +case $selected_distro in + CentOS) + selected_libc_version=$(select_libc $this_libc_version "${CentOS_libc_preset_version[@]}") + ;; + Debian) + selected_libc_version=$(select_libc $this_libc_version "${Debian_libc_preset_version[@]}") + ;; +esac + +[[ -z $selected_libc_version ]] && { + echo "No suitable GCC found to download for your environment: $this_distro, glibc-$this_libc_version" 1>&2 + echo "Please invoke $this_dir/build-gcc.sh to build one manually" 1>&2 + exit 1 +} + +selected_archive=vesoft-gcc-$version-$selected_distro-$(uname -m)-glibc-$selected_libc_version.sh + +url=$url_base/$selected_archive +$download_cmd $url +[[ $? -ne 0 ]] && { + echo "Downloading $selected_archive failed" 1>&2 + exit 1 +} + +bash $selected_archive $@ + +rm -rf $selected_archive diff --git a/third-party/install-third-party.sh b/third-party/install-third-party.sh new file mode 100755 index 00000000..028cc644 --- /dev/null +++ b/third-party/install-third-party.sh @@ -0,0 +1,104 @@ +#! /usr/bin/env bash + +# Copyright (c) 2019 vesoft inc. All rights reserved. +# +# This source code is licensed under Apache 2.0 License, +# attached with Common Clause Condition 1.0, found in the LICENSES directory. + +# Usage: install-third-party.sh --prefix=/opt/vesoft/third-party + +[[ $(uname) = Linux ]] || { + echo "Only Linux is supported" + exit 1 +} + +# Always use bash +shell=$(basename $(readlink /proc/$$/exe)) +if [ ! x$shell = x"bash" ] +then + bash $0 $@ + exit $? +fi + +[[ -z $version ]] && version=2.0 +url_base=https://oss-cdn.nebula-graph.com.cn/third-party/$version +this_dir=$(dirname $(readlink -f $0)) +cxx_cmd=${CXX:-g++} + +# We consider two derivatives: Red Hat and Debian +# Place preset libc versions of each from newer to older +libc_preset_versions=( 2.32 2.31 2.28 2.27 2.23 2.17 ) +gcc_preset_versions=( 10.1.0 9.3.0 9.2.0 9.1.0 8.3.0 7.5.0 7.1.0 ) + +selected_libc_version= +selected_gcc_version= +selected_archive= +this_libc_version=$(ldd --version | head -1 | cut -d ')' -f 2 | cut -d ' ' -f 2) +this_gcc_version=$($cxx_cmd -dumpfullversion -dumpversion) +this_abi_version=$($this_dir/cxx-compiler-abi-version.sh) + +hash wget &>/dev/null || { + echo "'wget' not fould, please install it first" 1>&2 + exit 1 +} + +download_cmd="wget -c" +if [[ -t 1 ]] +then + wget --help | grep -q '\--show-progress' && \ + download_cmd="$download_cmd -q --show-progress" || \ + download_cmd="$download_cmd --progress=bar:force:noscroll" +else + download_cmd="$download_cmd -q" +fi + +function version_cmp { + mapfile -t left < <( echo $1 | tr . '\n' ) + mapfile -t right < <( echo $2 | tr . '\n') + local i + for i in ${!left[@]} + do + local lv=${left[$i]} + local rv=${right[$i]} + [[ -z $rv ]] && { echo $lv; return; } + [[ $lv -ne $rv ]] && { echo $((lv - rv)); return; } + done + ((i++)) + rv=${right[$i]} + [[ ${#right[@]} -gt ${#left[@]} ]] && { echo $((0-rv)); return; } +} + +# Find the maximum version not greater than the system one +function select_by_version { + local this_version=$1 + shift 1 + local candidates="$@" + for v in $candidates + do + if [[ $(version_cmp $v $this_version) -le 0 ]] + then + echo $v + break + fi + done +} + +selected_libc_version=$(select_by_version $this_libc_version "${libc_preset_versions[@]}") +selected_gcc_version=$(select_by_version $this_gcc_version "${gcc_preset_versions[@]}") + +[[ -z $selected_libc_version ]] && { + echo "No prebuilt third-party found for your environment: libc-$this_libc_version, GCC-$this_gcc_version, ABI $this_abi_version" 1>&2 + exit 1 +} + +selected_archive=vesoft-third-party-$version-$(uname -m)-libc-$selected_libc_version-gcc-$selected_gcc_version-abi-$this_abi_version.sh + +url=$url_base/$selected_archive +echo "Downloading $selected_archive..." +$download_cmd $url +[[ $? -ne 0 ]] && { + echo "Downloading $selected_archive failed" 1>&2 + exit 1 +} + +bash $selected_archive $@ && rm -rf $selected_archive From e394af1681d02adb130af4be87477cbb352a3868 Mon Sep 17 00:00:00 2001 From: Shylock Hg <33566796+Shylock-Hg@users.noreply.github.com> Date: Tue, 12 Oct 2021 17:43:51 +0800 Subject: [PATCH 04/14] Test stateless query. --- src/client/tests/ConnectionTest.cpp | 22 ++++++++++++---------- src/client/tests/SessionTest.cpp | 16 +++++++++------- 2 files changed, 21 insertions(+), 17 deletions(-) diff --git a/src/client/tests/ConnectionTest.cpp b/src/client/tests/ConnectionTest.cpp index e04f0492..ab20381d 100644 --- a/src/client/tests/ConnectionTest.cpp +++ b/src/client/tests/ConnectionTest.cpp @@ -24,13 +24,13 @@ class ConnectionTest : public ClientTest { EXPECT_FALSE(c.ping()); // execute - auto resp = c.execute(-1, "SHOW SPACES"); + auto resp = c.execute(-1, "YIELD 1"); ASSERT_TRUE(resp.errorCode == nebula::ErrorCode::E_DISCONNECTED || resp.errorCode == nebula::ErrorCode::E_RPC_FAILURE); EXPECT_EQ(resp.data, nullptr); // async execute - c.asyncExecute(-1, "SHOW SPACES", [](auto &&cbResp) { + c.asyncExecute(-1, "YIELD 1", [](auto &&cbResp) { ASSERT_TRUE(cbResp.errorCode == nebula::ErrorCode::E_DISCONNECTED || cbResp.errorCode == nebula::ErrorCode::E_RPC_FAILURE); EXPECT_EQ(cbResp.data, nullptr); @@ -47,9 +47,10 @@ class ConnectionTest : public ClientTest { ASSERT_EQ(authResp.errorCode, nebula::ErrorCode::SUCCEEDED); // execute - resp = c.execute(*authResp.sessionId, "SHOW SPACES"); + resp = c.execute(*authResp.sessionId, "YIELD 1"); ASSERT_EQ(resp.errorCode, nebula::ErrorCode::SUCCEEDED); - nebula::DataSet expected({"Name"}); + nebula::DataSet expected({"1"}); + expected.emplace_back(nebula::List({1})); EXPECT_TRUE(verifyResultWithoutOrder(*resp.data, expected)); // explain @@ -60,10 +61,11 @@ class ConnectionTest : public ClientTest { // async execute folly::Baton<> b; - c.asyncExecute(*authResp.sessionId, "SHOW SPACES", [&b](auto &&cbResp) { + c.asyncExecute(*authResp.sessionId, "YIELD 1", [&b](auto &&cbResp) { ASSERT_EQ(cbResp.errorCode, nebula::ErrorCode::SUCCEEDED) << static_cast(cbResp.errorCode); - nebula::DataSet cbExpected({"Name"}); + nebula::DataSet cbExpected({"1"}); + cbExpected.emplace_back(nebula::List({1})); EXPECT_TRUE(verifyResultWithoutOrder(*cbResp.data, cbExpected)); b.post(); }); @@ -80,12 +82,12 @@ class ConnectionTest : public ClientTest { EXPECT_TRUE(c.ping()); // check signout - resp = c.execute(*authResp.sessionId, "SHOW SPACES"); + resp = c.execute(*authResp.sessionId, "YIELD 1"); ASSERT_EQ(resp.errorCode, nebula::ErrorCode::E_SESSION_INVALID); // async execute folly::Baton<> b1; - c.asyncExecute(*authResp.sessionId, "SHOW SPACES", [&b1](auto &&cbResp) { + c.asyncExecute(*authResp.sessionId, "YIELD 1", [&b1](auto &&cbResp) { ASSERT_EQ(cbResp.errorCode, nebula::ErrorCode::E_SESSION_INVALID); b1.post(); }); @@ -98,12 +100,12 @@ class ConnectionTest : public ClientTest { EXPECT_FALSE(c.ping()); // execute - resp = c.execute(*authResp.sessionId, "SHOW SPACES"); + resp = c.execute(*authResp.sessionId, "YIELD 1"); ASSERT_EQ(resp.errorCode, nebula::ErrorCode::E_DISCONNECTED); // async execute folly::Baton<> b2; - c.asyncExecute(*authResp.sessionId, "SHOW SPACES", [&b2](auto &&cbResp) { + c.asyncExecute(*authResp.sessionId, "YIELD 1", [&b2](auto &&cbResp) { ASSERT_EQ(cbResp.errorCode, nebula::ErrorCode::E_DISCONNECTED); b2.post(); }); diff --git a/src/client/tests/SessionTest.cpp b/src/client/tests/SessionTest.cpp index d3b5ef85..0c09bf78 100644 --- a/src/client/tests/SessionTest.cpp +++ b/src/client/tests/SessionTest.cpp @@ -34,9 +34,10 @@ class SessionTest : public ClientTest { EXPECT_TRUE(session.ping()); // execute - auto result = session.execute("SHOW SPACES"); + auto result = session.execute("YIELD 1"); ASSERT_EQ(result.errorCode, nebula::ErrorCode::SUCCEEDED); - nebula::DataSet expected({"Name"}); + nebula::DataSet expected({"1"}); + expected.emplace_back(nebula::List({1})); EXPECT_TRUE(verifyResultWithoutOrder(*result.data, expected)); // explain @@ -47,9 +48,10 @@ class SessionTest : public ClientTest { // async execute folly::Baton<> b; - session.asyncExecute("SHOW SPACES", [&b](auto&& cbResult) { + session.asyncExecute("YIELD 1", [&b](auto&& cbResult) { ASSERT_EQ(cbResult.errorCode, nebula::ErrorCode::SUCCEEDED); - nebula::DataSet cbExpected({"Name"}); + nebula::DataSet cbExpected({"1"}); + cbExpected.emplace_back(nebula::List({1})); EXPECT_TRUE(verifyResultWithoutOrder(*cbResult.data, cbExpected)); b.post(); }); @@ -59,7 +61,7 @@ class SessionTest : public ClientTest { ASSERT_EQ(session.retryConnect(), nebula::ErrorCode::SUCCEEDED); // execute - result = session.execute("SHOW SPACES"); + result = session.execute("YIELD 1"); ASSERT_EQ(result.errorCode, nebula::ErrorCode::SUCCEEDED); EXPECT_TRUE(verifyResultWithoutOrder(*result.data, expected)); @@ -72,12 +74,12 @@ class SessionTest : public ClientTest { EXPECT_FALSE(session.ping()); // check release - result = session.execute("SHOW SPACES"); + result = session.execute("YIELD 1"); ASSERT_EQ(result.errorCode, nebula::ErrorCode::E_DISCONNECTED); // async execute folly::Baton<> b2; - session.asyncExecute("SHOW SPACES", [&b2](auto&& cbResult) { + session.asyncExecute("YIELD 1", [&b2](auto&& cbResult) { ASSERT_EQ(cbResult.errorCode, nebula::ErrorCode::E_DISCONNECTED); b2.post(); }); From 91c1765f15787ff180307c04b9c62fc703de87d5 Mon Sep 17 00:00:00 2001 From: Shylock Hg <33566796+Shylock-Hg@users.noreply.github.com> Date: Tue, 12 Oct 2021 19:05:01 +0800 Subject: [PATCH 05/14] Tune test. --- src/client/tests/ConnectionTest.cpp | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/client/tests/ConnectionTest.cpp b/src/client/tests/ConnectionTest.cpp index ab20381d..ebe3b6e8 100644 --- a/src/client/tests/ConnectionTest.cpp +++ b/src/client/tests/ConnectionTest.cpp @@ -142,6 +142,8 @@ TEST_F(ConnectionTest, Timeout) { "show spaces;show spaces;show spaces;show spaces;" "show spaces;show spaces;show spaces;show spaces;" "show spaces;show spaces;show spaces;show spaces;" + "show spaces;show spaces;show spaces;show spaces;" + "show spaces;show spaces;show spaces;show spaces;" "show spaces;show spaces;show spaces;show spaces;"); ASSERT_EQ(resp.errorCode, nebula::ErrorCode::E_RPC_FAILURE); } From b957f6a99715d6b9e52f9c3184dd6fe5f5c47964 Mon Sep 17 00:00:00 2001 From: Shylock Hg <33566796+Shylock-Hg@users.noreply.github.com> Date: Tue, 12 Oct 2021 19:12:06 +0800 Subject: [PATCH 06/14] Tune test. --- src/client/tests/SessionTest.cpp | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/client/tests/SessionTest.cpp b/src/client/tests/SessionTest.cpp index 0c09bf78..9d36b890 100644 --- a/src/client/tests/SessionTest.cpp +++ b/src/client/tests/SessionTest.cpp @@ -156,6 +156,8 @@ TEST_F(SessionTest, Timeout) { "show spaces;show spaces;show spaces;show spaces;" "show spaces;show spaces;show spaces;show spaces;" "show spaces;show spaces;show spaces;show spaces;" + "show spaces;show spaces;show spaces;show spaces;" + "show spaces;show spaces;show spaces;show spaces;" "show spaces;show spaces;show spaces;show spaces;"); ASSERT_EQ(resp.errorCode, nebula::ErrorCode::E_RPC_FAILURE); } From aafb7e63065bd1c950932ced33640600397c4800 Mon Sep 17 00:00:00 2001 From: Shylock Hg <33566796+Shylock-Hg@users.noreply.github.com> Date: Tue, 12 Oct 2021 19:18:31 +0800 Subject: [PATCH 07/14] Tune test. --- src/client/tests/ConnectionTest.cpp | 2 ++ src/client/tests/SessionTest.cpp | 2 ++ 2 files changed, 4 insertions(+) diff --git a/src/client/tests/ConnectionTest.cpp b/src/client/tests/ConnectionTest.cpp index ebe3b6e8..b4e8eca1 100644 --- a/src/client/tests/ConnectionTest.cpp +++ b/src/client/tests/ConnectionTest.cpp @@ -144,6 +144,8 @@ TEST_F(ConnectionTest, Timeout) { "show spaces;show spaces;show spaces;show spaces;" "show spaces;show spaces;show spaces;show spaces;" "show spaces;show spaces;show spaces;show spaces;" + "show spaces;show spaces;show spaces;show spaces;" + "show spaces;show spaces;show spaces;show spaces;" "show spaces;show spaces;show spaces;show spaces;"); ASSERT_EQ(resp.errorCode, nebula::ErrorCode::E_RPC_FAILURE); } diff --git a/src/client/tests/SessionTest.cpp b/src/client/tests/SessionTest.cpp index 9d36b890..c0e45ceb 100644 --- a/src/client/tests/SessionTest.cpp +++ b/src/client/tests/SessionTest.cpp @@ -158,6 +158,8 @@ TEST_F(SessionTest, Timeout) { "show spaces;show spaces;show spaces;show spaces;" "show spaces;show spaces;show spaces;show spaces;" "show spaces;show spaces;show spaces;show spaces;" + "show spaces;show spaces;show spaces;show spaces;" + "show spaces;show spaces;show spaces;show spaces;" "show spaces;show spaces;show spaces;show spaces;"); ASSERT_EQ(resp.errorCode, nebula::ErrorCode::E_RPC_FAILURE); } From ae5679971395254fb321749a9e8684ce2b611aa5 Mon Sep 17 00:00:00 2001 From: Shylock Hg <33566796+Shylock-Hg@users.noreply.github.com> Date: Wed, 13 Oct 2021 10:04:55 +0800 Subject: [PATCH 08/14] Tune test. --- src/client/tests/ConnectionTest.cpp | 2 ++ src/client/tests/SessionTest.cpp | 2 ++ 2 files changed, 4 insertions(+) diff --git a/src/client/tests/ConnectionTest.cpp b/src/client/tests/ConnectionTest.cpp index b4e8eca1..cfcd97ab 100644 --- a/src/client/tests/ConnectionTest.cpp +++ b/src/client/tests/ConnectionTest.cpp @@ -146,6 +146,8 @@ TEST_F(ConnectionTest, Timeout) { "show spaces;show spaces;show spaces;show spaces;" "show spaces;show spaces;show spaces;show spaces;" "show spaces;show spaces;show spaces;show spaces;" + "show spaces;show spaces;show spaces;show spaces;" + "show spaces;show spaces;show spaces;show spaces;" "show spaces;show spaces;show spaces;show spaces;"); ASSERT_EQ(resp.errorCode, nebula::ErrorCode::E_RPC_FAILURE); } diff --git a/src/client/tests/SessionTest.cpp b/src/client/tests/SessionTest.cpp index c0e45ceb..1b932ef6 100644 --- a/src/client/tests/SessionTest.cpp +++ b/src/client/tests/SessionTest.cpp @@ -160,6 +160,8 @@ TEST_F(SessionTest, Timeout) { "show spaces;show spaces;show spaces;show spaces;" "show spaces;show spaces;show spaces;show spaces;" "show spaces;show spaces;show spaces;show spaces;" + "show spaces;show spaces;show spaces;show spaces;" + "show spaces;show spaces;show spaces;show spaces;" "show spaces;show spaces;show spaces;show spaces;"); ASSERT_EQ(resp.errorCode, nebula::ErrorCode::E_RPC_FAILURE); } From 8958d9d5369382d4f3620294f66cc6d2f5af733d Mon Sep 17 00:00:00 2001 From: Shylock Hg <33566796+Shylock-Hg@users.noreply.github.com> Date: Wed, 13 Oct 2021 10:25:43 +0800 Subject: [PATCH 09/14] Tune test. --- src/client/tests/ConnectionTest.cpp | 26 +++++++++++--------------- src/client/tests/SessionTest.cpp | 23 +++++++++-------------- 2 files changed, 20 insertions(+), 29 deletions(-) diff --git a/src/client/tests/ConnectionTest.cpp b/src/client/tests/ConnectionTest.cpp index cfcd97ab..db16360f 100644 --- a/src/client/tests/ConnectionTest.cpp +++ b/src/client/tests/ConnectionTest.cpp @@ -134,22 +134,18 @@ TEST_F(ConnectionTest, Timeout) { ASSERT_EQ(authResp.errorCode, nebula::ErrorCode::SUCCEEDED); // execute - auto resp = c.execute(*authResp.sessionId, - "show spaces;show spaces;show spaces;show spaces;" - "show spaces;show spaces;show spaces;show spaces;" - "show spaces;show spaces;show spaces;show spaces;" - "show spaces;show spaces;show spaces;show spaces;" - "show spaces;show spaces;show spaces;show spaces;" - "show spaces;show spaces;show spaces;show spaces;" - "show spaces;show spaces;show spaces;show spaces;" - "show spaces;show spaces;show spaces;show spaces;" - "show spaces;show spaces;show spaces;show spaces;" - "show spaces;show spaces;show spaces;show spaces;" - "show spaces;show spaces;show spaces;show spaces;" - "show spaces;show spaces;show spaces;show spaces;" - "show spaces;show spaces;show spaces;show spaces;" - "show spaces;show spaces;show spaces;show spaces;"); + auto resp = + c.execute(*authResp.sessionId, "use nba;GO 100000 STEPS FROM 'Tim Duncan' OVER like;"); ASSERT_EQ(resp.errorCode, nebula::ErrorCode::E_RPC_FAILURE); + + resp = c.execute( + *authResp.sessionId, + "SHOW QUERIES " + "| YIELD $-.SessionID AS sid, $-.ExecutionPlanID AS eid, $-.DurationInUSec AS dur " + "WHERE $-.DurationInUSec > 1000000 AND $-.`Query` CONTAINS 'GO' " + "| ORDER BY $-.dur " + "| KILL QUERY(session=$-.sid, plan=$-.eid)"); + ASSERT_EQ(resp.errorCode, nebula::ErrorCode::SUCCEEDED); } int main(int argc, char **argv) { diff --git a/src/client/tests/SessionTest.cpp b/src/client/tests/SessionTest.cpp index 1b932ef6..4dd6ab41 100644 --- a/src/client/tests/SessionTest.cpp +++ b/src/client/tests/SessionTest.cpp @@ -149,21 +149,16 @@ TEST_F(SessionTest, Timeout) { ASSERT_TRUE(session.valid()); // execute - auto resp = session.execute("show spaces;show spaces;show spaces;show spaces;" - "show spaces;show spaces;show spaces;show spaces;" - "show spaces;show spaces;show spaces;show spaces;" - "show spaces;show spaces;show spaces;show spaces;" - "show spaces;show spaces;show spaces;show spaces;" - "show spaces;show spaces;show spaces;show spaces;" - "show spaces;show spaces;show spaces;show spaces;" - "show spaces;show spaces;show spaces;show spaces;" - "show spaces;show spaces;show spaces;show spaces;" - "show spaces;show spaces;show spaces;show spaces;" - "show spaces;show spaces;show spaces;show spaces;" - "show spaces;show spaces;show spaces;show spaces;" - "show spaces;show spaces;show spaces;show spaces;" - "show spaces;show spaces;show spaces;show spaces;"); + auto resp = session.execute("use nba;GO 100000 STEPS FROM 'Tim Duncan' OVER like;"); ASSERT_EQ(resp.errorCode, nebula::ErrorCode::E_RPC_FAILURE); + + resp = session.execute( + "SHOW QUERIES " + "| YIELD $-.SessionID AS sid, $-.ExecutionPlanID AS eid, $-.DurationInUSec AS dur " + "WHERE $-.DurationInUSec > 1000000 AND $-.`Query` CONTAINS 'GO' " + "| ORDER BY $-.dur " + "| KILL QUERY(session=$-.sid, plan=$-.eid)"); + ASSERT_EQ(resp.errorCode, nebula::ErrorCode::SUCCEEDED); } int main(int argc, char** argv) { From a3bf75bbb1095303657686c0eef2f81690f2441d Mon Sep 17 00:00:00 2001 From: Shylock Hg <33566796+Shylock-Hg@users.noreply.github.com> Date: Wed, 13 Oct 2021 10:34:06 +0800 Subject: [PATCH 10/14] Log error message. --- src/client/tests/ConnectionTest.cpp | 2 +- src/client/tests/SessionTest.cpp | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/client/tests/ConnectionTest.cpp b/src/client/tests/ConnectionTest.cpp index db16360f..0f01b1fc 100644 --- a/src/client/tests/ConnectionTest.cpp +++ b/src/client/tests/ConnectionTest.cpp @@ -136,7 +136,7 @@ TEST_F(ConnectionTest, Timeout) { // execute auto resp = c.execute(*authResp.sessionId, "use nba;GO 100000 STEPS FROM 'Tim Duncan' OVER like;"); - ASSERT_EQ(resp.errorCode, nebula::ErrorCode::E_RPC_FAILURE); + ASSERT_EQ(resp.errorCode, nebula::ErrorCode::E_RPC_FAILURE) << *resp.errorMsg; resp = c.execute( *authResp.sessionId, diff --git a/src/client/tests/SessionTest.cpp b/src/client/tests/SessionTest.cpp index 4dd6ab41..7386f7f2 100644 --- a/src/client/tests/SessionTest.cpp +++ b/src/client/tests/SessionTest.cpp @@ -150,7 +150,7 @@ TEST_F(SessionTest, Timeout) { // execute auto resp = session.execute("use nba;GO 100000 STEPS FROM 'Tim Duncan' OVER like;"); - ASSERT_EQ(resp.errorCode, nebula::ErrorCode::E_RPC_FAILURE); + ASSERT_EQ(resp.errorCode, nebula::ErrorCode::E_RPC_FAILURE) << *resp.errorMsg; resp = session.execute( "SHOW QUERIES " From 0a659a30f86e21de21965f737100a52475b93297 Mon Sep 17 00:00:00 2001 From: Shylock Hg <33566796+Shylock-Hg@users.noreply.github.com> Date: Wed, 13 Oct 2021 10:58:43 +0800 Subject: [PATCH 11/14] Tune test. --- src/client/tests/ConnectionTest.cpp | 18 ++++++++++++++++-- src/client/tests/SessionTest.cpp | 15 ++++++++++++++- 2 files changed, 30 insertions(+), 3 deletions(-) diff --git a/src/client/tests/ConnectionTest.cpp b/src/client/tests/ConnectionTest.cpp index 0f01b1fc..c0c2e446 100644 --- a/src/client/tests/ConnectionTest.cpp +++ b/src/client/tests/ConnectionTest.cpp @@ -133,9 +133,20 @@ TEST_F(ConnectionTest, Timeout) { auto authResp = c.authenticate("root", "nebula"); ASSERT_EQ(authResp.errorCode, nebula::ErrorCode::SUCCEEDED); + auto resp = c.execute(*authResp.sessionId, + "CREATE SPACE IF NOT EXISTS test(vid_type = FIXED_STRING(16));use " + "test;CREATE EDGE IF NOT EXISTS like();"); + ASSERT_EQ(resp.errorCode, nebula::ErrorCode::SUCCEEDED) << *resp.errorMsg; + + ::sleep(30); + + resp = c.execute(*authResp.sessionId, + "INSERT EDGE like() VALUES 'Tim Duncan'->'Tony Parker':(), 'Tony " + "Parker'->'Tim Duncan':();"); + ASSERT_EQ(resp.errorCode, nebula::ErrorCode::SUCCEEDED); + // execute - auto resp = - c.execute(*authResp.sessionId, "use nba;GO 100000 STEPS FROM 'Tim Duncan' OVER like;"); + resp = c.execute(*authResp.sessionId, "use nba;GO 100000 STEPS FROM 'Tim Duncan' OVER like;"); ASSERT_EQ(resp.errorCode, nebula::ErrorCode::E_RPC_FAILURE) << *resp.errorMsg; resp = c.execute( @@ -146,6 +157,9 @@ TEST_F(ConnectionTest, Timeout) { "| ORDER BY $-.dur " "| KILL QUERY(session=$-.sid, plan=$-.eid)"); ASSERT_EQ(resp.errorCode, nebula::ErrorCode::SUCCEEDED); + + resp = c.execute(*authResp.sessionId, "DROP SPACE IF EXISTS test"); + ASSERT_EQ(resp.errorCode, nebula::ErrorCode::SUCCEEDED); } int main(int argc, char **argv) { diff --git a/src/client/tests/SessionTest.cpp b/src/client/tests/SessionTest.cpp index 7386f7f2..198197d1 100644 --- a/src/client/tests/SessionTest.cpp +++ b/src/client/tests/SessionTest.cpp @@ -148,8 +148,18 @@ TEST_F(SessionTest, Timeout) { auto session = pool.getSession("root", "nebula"); ASSERT_TRUE(session.valid()); + auto resp = session.execute("CREATE SPACE IF NOT EXISTS test(vid_type = FIXED_STRING(16));use " + "test;CREATE EDGE IF NOT EXISTS like();"); + ASSERT_EQ(resp.errorCode, nebula::ErrorCode::SUCCEEDED) << *resp.errorMsg; + + ::sleep(30); + + resp = session.execute("INSERT EDGE like() VALUES 'Tim Duncan'->'Tony Parker':(), 'Tony " + "Parker'->'Tim Duncan':();"); + ASSERT_EQ(resp.errorCode, nebula::ErrorCode::SUCCEEDED); + // execute - auto resp = session.execute("use nba;GO 100000 STEPS FROM 'Tim Duncan' OVER like;"); + resp = session.execute("use nba;GO 100000 STEPS FROM 'Tim Duncan' OVER like;"); ASSERT_EQ(resp.errorCode, nebula::ErrorCode::E_RPC_FAILURE) << *resp.errorMsg; resp = session.execute( @@ -159,6 +169,9 @@ TEST_F(SessionTest, Timeout) { "| ORDER BY $-.dur " "| KILL QUERY(session=$-.sid, plan=$-.eid)"); ASSERT_EQ(resp.errorCode, nebula::ErrorCode::SUCCEEDED); + + resp = session.execute("DROP SPACE IF EXISTS test"); + ASSERT_EQ(resp.errorCode, nebula::ErrorCode::SUCCEEDED); } int main(int argc, char** argv) { From 8dd4a475d0cf25f239514db63f5060dcdc8c106e Mon Sep 17 00:00:00 2001 From: Shylock Hg <33566796+Shylock-Hg@users.noreply.github.com> Date: Wed, 13 Oct 2021 11:36:09 +0800 Subject: [PATCH 12/14] Tune test. --- src/client/tests/ConnectionTest.cpp | 11 ++++++----- src/client/tests/SessionTest.cpp | 11 ++++++----- 2 files changed, 12 insertions(+), 10 deletions(-) diff --git a/src/client/tests/ConnectionTest.cpp b/src/client/tests/ConnectionTest.cpp index c0c2e446..ee3ba30b 100644 --- a/src/client/tests/ConnectionTest.cpp +++ b/src/client/tests/ConnectionTest.cpp @@ -127,15 +127,15 @@ TEST_F(ConnectionTest, Basic) { TEST_F(ConnectionTest, Timeout) { nebula::Connection c; - ASSERT_TRUE(c.open(kServerHost, 9669, 5)); + ASSERT_TRUE(c.open(kServerHost, 9669, 10)); // auth auto authResp = c.authenticate("root", "nebula"); ASSERT_EQ(authResp.errorCode, nebula::ErrorCode::SUCCEEDED); auto resp = c.execute(*authResp.sessionId, - "CREATE SPACE IF NOT EXISTS test(vid_type = FIXED_STRING(16));use " - "test;CREATE EDGE IF NOT EXISTS like();"); + "CREATE SPACE IF NOT EXISTS conn_test(vid_type = FIXED_STRING(16));use " + "conn_test;CREATE EDGE IF NOT EXISTS like();"); ASSERT_EQ(resp.errorCode, nebula::ErrorCode::SUCCEEDED) << *resp.errorMsg; ::sleep(30); @@ -146,7 +146,8 @@ TEST_F(ConnectionTest, Timeout) { ASSERT_EQ(resp.errorCode, nebula::ErrorCode::SUCCEEDED); // execute - resp = c.execute(*authResp.sessionId, "use nba;GO 100000 STEPS FROM 'Tim Duncan' OVER like;"); + resp = c.execute(*authResp.sessionId, + "use conn_test;GO 100000 STEPS FROM 'Tim Duncan' OVER like;"); ASSERT_EQ(resp.errorCode, nebula::ErrorCode::E_RPC_FAILURE) << *resp.errorMsg; resp = c.execute( @@ -158,7 +159,7 @@ TEST_F(ConnectionTest, Timeout) { "| KILL QUERY(session=$-.sid, plan=$-.eid)"); ASSERT_EQ(resp.errorCode, nebula::ErrorCode::SUCCEEDED); - resp = c.execute(*authResp.sessionId, "DROP SPACE IF EXISTS test"); + resp = c.execute(*authResp.sessionId, "DROP SPACE IF EXISTS conn_test"); ASSERT_EQ(resp.errorCode, nebula::ErrorCode::SUCCEEDED); } diff --git a/src/client/tests/SessionTest.cpp b/src/client/tests/SessionTest.cpp index 198197d1..8434b5f0 100644 --- a/src/client/tests/SessionTest.cpp +++ b/src/client/tests/SessionTest.cpp @@ -143,13 +143,14 @@ TEST_F(SessionTest, InvalidAddress) { TEST_F(SessionTest, Timeout) { nebula::ConnectionPool pool; - nebula::Config c{5, 0, 10, 0}; + nebula::Config c{10, 0, 10, 0}; pool.init({kServerHost ":9669"}, c); auto session = pool.getSession("root", "nebula"); ASSERT_TRUE(session.valid()); - auto resp = session.execute("CREATE SPACE IF NOT EXISTS test(vid_type = FIXED_STRING(16));use " - "test;CREATE EDGE IF NOT EXISTS like();"); + auto resp = + session.execute("CREATE SPACE IF NOT EXISTS session_test(vid_type = FIXED_STRING(16));use " + "session_test;CREATE EDGE IF NOT EXISTS like();"); ASSERT_EQ(resp.errorCode, nebula::ErrorCode::SUCCEEDED) << *resp.errorMsg; ::sleep(30); @@ -159,7 +160,7 @@ TEST_F(SessionTest, Timeout) { ASSERT_EQ(resp.errorCode, nebula::ErrorCode::SUCCEEDED); // execute - resp = session.execute("use nba;GO 100000 STEPS FROM 'Tim Duncan' OVER like;"); + resp = session.execute("use session_test;GO 100000 STEPS FROM 'Tim Duncan' OVER like;"); ASSERT_EQ(resp.errorCode, nebula::ErrorCode::E_RPC_FAILURE) << *resp.errorMsg; resp = session.execute( @@ -170,7 +171,7 @@ TEST_F(SessionTest, Timeout) { "| KILL QUERY(session=$-.sid, plan=$-.eid)"); ASSERT_EQ(resp.errorCode, nebula::ErrorCode::SUCCEEDED); - resp = session.execute("DROP SPACE IF EXISTS test"); + resp = session.execute("DROP SPACE IF EXISTS session_test"); ASSERT_EQ(resp.errorCode, nebula::ErrorCode::SUCCEEDED); } From ae9ae7432cee7a3d6032340393abd59f39adea10 Mon Sep 17 00:00:00 2001 From: Shylock Hg <33566796+Shylock-Hg@users.noreply.github.com> Date: Wed, 13 Oct 2021 11:46:37 +0800 Subject: [PATCH 13/14] Install headers. --- CMakeLists.txt | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/CMakeLists.txt b/CMakeLists.txt index 0cc561b9..2501177c 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -82,6 +82,12 @@ install( PATTERN ".gitkeep" EXCLUDE ) +install( + DIRECTORY include/common + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR} + PATTERN ".gitkeep" EXCLUDE +) + add_custom_target( format COMMAND "find" "include" "src/client" "src/datatypes" "src/time" "src/graph" "-type" "f" "\\(" "-iname" "\\*.h" "-o" "-iname" "\\*.cpp" "\\)" "|" "xargs" "clang-format" "-i" From 8b277ebed2ff60deaeb7fdb30eecc8418adfe8a6 Mon Sep 17 00:00:00 2001 From: Shylock Hg <33566796+Shylock-Hg@users.noreply.github.com> Date: Wed, 13 Oct 2021 11:55:18 +0800 Subject: [PATCH 14/14] Tune test. --- src/client/tests/ConnectionTest.cpp | 2 +- src/client/tests/SessionTest.cpp | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/client/tests/ConnectionTest.cpp b/src/client/tests/ConnectionTest.cpp index ee3ba30b..0aa768c7 100644 --- a/src/client/tests/ConnectionTest.cpp +++ b/src/client/tests/ConnectionTest.cpp @@ -143,7 +143,7 @@ TEST_F(ConnectionTest, Timeout) { resp = c.execute(*authResp.sessionId, "INSERT EDGE like() VALUES 'Tim Duncan'->'Tony Parker':(), 'Tony " "Parker'->'Tim Duncan':();"); - ASSERT_EQ(resp.errorCode, nebula::ErrorCode::SUCCEEDED); + ASSERT_EQ(resp.errorCode, nebula::ErrorCode::SUCCEEDED) << *resp.errorMsg; // execute resp = c.execute(*authResp.sessionId, diff --git a/src/client/tests/SessionTest.cpp b/src/client/tests/SessionTest.cpp index 8434b5f0..41dd1dd4 100644 --- a/src/client/tests/SessionTest.cpp +++ b/src/client/tests/SessionTest.cpp @@ -157,7 +157,7 @@ TEST_F(SessionTest, Timeout) { resp = session.execute("INSERT EDGE like() VALUES 'Tim Duncan'->'Tony Parker':(), 'Tony " "Parker'->'Tim Duncan':();"); - ASSERT_EQ(resp.errorCode, nebula::ErrorCode::SUCCEEDED); + ASSERT_EQ(resp.errorCode, nebula::ErrorCode::SUCCEEDED) << *resp.errorMsg; // execute resp = session.execute("use session_test;GO 100000 STEPS FROM 'Tim Duncan' OVER like;");